repo_name
stringclasses 6
values | pr_number
int64 512
78.9k
| pr_title
stringlengths 3
144
| pr_description
stringlengths 0
30.3k
| author
stringlengths 2
21
| date_created
timestamp[ns, tz=UTC] | date_merged
timestamp[ns, tz=UTC] | previous_commit
stringlengths 40
40
| pr_commit
stringlengths 40
40
| query
stringlengths 17
30.4k
| filepath
stringlengths 9
210
| before_content
stringlengths 0
112M
| after_content
stringlengths 0
112M
| label
int64 -1
1
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Composition.TypedParts/src/System/Composition/Hosting/ContainerConfiguration.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Composition.Convention;
using System.Composition.Debugging;
using System.Composition.Hosting.Core;
using System.Composition.TypedParts;
using System.Composition.TypedParts.Util;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
namespace System.Composition.Hosting
{
/// <summary>
/// Configures and constructs a lightweight container.
/// </summary>
[DebuggerTypeProxy(typeof(ContainerConfigurationDebuggerProxy))]
public class ContainerConfiguration
{
private AttributedModelProvider _defaultAttributeContext;
private readonly IList<ExportDescriptorProvider> _addedSources = new List<ExportDescriptorProvider>();
private readonly IList<Tuple<IEnumerable<Type>, AttributedModelProvider>> _types = new List<Tuple<IEnumerable<Type>, AttributedModelProvider>>();
/// <summary>
/// Create the container. The value returned from this method provides
/// the exports in the container, as well as a means to dispose the container.
/// </summary>
/// <returns>The container.</returns>
public CompositionHost CreateContainer()
{
var providers = _addedSources.ToList();
foreach (var typeSet in _types)
{
var ac = typeSet.Item2 ?? _defaultAttributeContext ?? new DirectAttributeContext();
providers.Add(new TypedPartExportDescriptorProvider(typeSet.Item1, ac));
}
return CompositionHost.CreateCompositionHost(providers.ToArray());
}
/// <summary>
/// Add an export descriptor provider to the container.
/// </summary>
/// <param name="exportDescriptorProvider">An export descriptor provider.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithProvider(ExportDescriptorProvider exportDescriptorProvider!!)
{
_addedSources.Add(exportDescriptorProvider);
return this;
}
/// <summary>
/// Add conventions defined using a <see cref="AttributedModelProvider"/> to the container.
/// These will be used as the default conventions; types and assemblies added with a
/// specific convention will use their own.
/// </summary>
/// <param name="conventions"></param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithDefaultConventions(AttributedModelProvider conventions!!)
{
if (_defaultAttributeContext != null)
throw new InvalidOperationException(SR.ContainerConfiguration_DefaultConventionSet);
_defaultAttributeContext = conventions;
return this;
}
/// <summary>
/// Add a part type to the container. If the part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="partType">The part type.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithPart(Type partType)
{
return WithPart(partType, null);
}
/// <summary>
/// Add a part type to the container. If the part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="partType">The part type.</param>
/// <param name="conventions">Conventions represented by a <see cref="AttributedModelProvider"/>, or null.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithPart(Type partType, AttributedModelProvider conventions)
{
if (partType == null) throw new ArgumentNullException(nameof(partType));
return WithParts(new[] { partType }, conventions);
}
/// <summary>
/// Add a part type to the container. If the part type does not have any exports it
/// will be ignored.
/// </summary>
/// <typeparam name="TPart">The part type.</typeparam>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithPart<TPart>()
{
return WithPart<TPart>(null);
}
/// <summary>
/// Add a part type to the container. If the part type does not have any exports it
/// will be ignored.
/// </summary>
/// <typeparam name="TPart">The part type.</typeparam>
/// <param name="conventions">Conventions represented by a <see cref="AttributedModelProvider"/>, or null.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithPart<TPart>(AttributedModelProvider conventions)
{
return WithPart(typeof(TPart), conventions);
}
/// <summary>
/// Add part types to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="partTypes">The part types.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithParts(params Type[] partTypes)
{
return WithParts((IEnumerable<Type>)partTypes);
}
/// <summary>
/// Add part types to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="partTypes">The part types.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithParts(IEnumerable<Type> partTypes)
{
return WithParts(partTypes, null);
}
/// <summary>
/// Add part types to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="partTypes">The part types.</param>
/// <param name="conventions">Conventions represented by a <see cref="AttributedModelProvider"/>, or null.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithParts(IEnumerable<Type> partTypes!!, AttributedModelProvider conventions)
{
_types.Add(Tuple.Create(partTypes, conventions));
return this;
}
/// <summary>
/// Add part types from an assembly to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="assembly">The assembly from which to add part types.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithAssembly(Assembly assembly)
{
return WithAssembly(assembly, null);
}
/// <summary>
/// Add part types from an assembly to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="assembly">The assembly from which to add part types.</param>
/// <param name="conventions">Conventions represented by a <see cref="AttributedModelProvider"/>, or null.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithAssembly(Assembly assembly, AttributedModelProvider conventions)
{
return WithAssemblies(new[] { assembly }, conventions);
}
/// <summary>
/// Add part types from a list of assemblies to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="assemblies">Assemblies containing part types.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithAssemblies(IEnumerable<Assembly> assemblies)
{
return WithAssemblies(assemblies, null);
}
/// <summary>
/// Add part types from a list of assemblies to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="assemblies">Assemblies containing part types.</param>
/// <param name="conventions">Conventions represented by a <see cref="AttributedModelProvider"/>, or null.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithAssemblies(IEnumerable<Assembly> assemblies!!, AttributedModelProvider conventions)
{
return WithParts(assemblies.SelectMany(a => a.DefinedTypes.Select(dt => dt.AsType())), conventions);
}
internal ExportDescriptorProvider[] DebugGetAddedExportDescriptorProviders()
{
return _addedSources.ToArray();
}
internal Tuple<IEnumerable<Type>, AttributedModelProvider>[] DebugGetRegisteredTypes()
{
return _types.ToArray();
}
internal AttributedModelProvider DebugGetDefaultAttributeContext()
{
return _defaultAttributeContext;
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Composition.Convention;
using System.Composition.Debugging;
using System.Composition.Hosting.Core;
using System.Composition.TypedParts;
using System.Composition.TypedParts.Util;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
namespace System.Composition.Hosting
{
/// <summary>
/// Configures and constructs a lightweight container.
/// </summary>
[DebuggerTypeProxy(typeof(ContainerConfigurationDebuggerProxy))]
public class ContainerConfiguration
{
private AttributedModelProvider _defaultAttributeContext;
private readonly IList<ExportDescriptorProvider> _addedSources = new List<ExportDescriptorProvider>();
private readonly IList<Tuple<IEnumerable<Type>, AttributedModelProvider>> _types = new List<Tuple<IEnumerable<Type>, AttributedModelProvider>>();
/// <summary>
/// Create the container. The value returned from this method provides
/// the exports in the container, as well as a means to dispose the container.
/// </summary>
/// <returns>The container.</returns>
public CompositionHost CreateContainer()
{
var providers = _addedSources.ToList();
foreach (var typeSet in _types)
{
var ac = typeSet.Item2 ?? _defaultAttributeContext ?? new DirectAttributeContext();
providers.Add(new TypedPartExportDescriptorProvider(typeSet.Item1, ac));
}
return CompositionHost.CreateCompositionHost(providers.ToArray());
}
/// <summary>
/// Add an export descriptor provider to the container.
/// </summary>
/// <param name="exportDescriptorProvider">An export descriptor provider.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithProvider(ExportDescriptorProvider exportDescriptorProvider!!)
{
_addedSources.Add(exportDescriptorProvider);
return this;
}
/// <summary>
/// Add conventions defined using a <see cref="AttributedModelProvider"/> to the container.
/// These will be used as the default conventions; types and assemblies added with a
/// specific convention will use their own.
/// </summary>
/// <param name="conventions"></param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithDefaultConventions(AttributedModelProvider conventions!!)
{
if (_defaultAttributeContext != null)
throw new InvalidOperationException(SR.ContainerConfiguration_DefaultConventionSet);
_defaultAttributeContext = conventions;
return this;
}
/// <summary>
/// Add a part type to the container. If the part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="partType">The part type.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithPart(Type partType)
{
return WithPart(partType, null);
}
/// <summary>
/// Add a part type to the container. If the part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="partType">The part type.</param>
/// <param name="conventions">Conventions represented by a <see cref="AttributedModelProvider"/>, or null.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithPart(Type partType, AttributedModelProvider conventions)
{
if (partType == null) throw new ArgumentNullException(nameof(partType));
return WithParts(new[] { partType }, conventions);
}
/// <summary>
/// Add a part type to the container. If the part type does not have any exports it
/// will be ignored.
/// </summary>
/// <typeparam name="TPart">The part type.</typeparam>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithPart<TPart>()
{
return WithPart<TPart>(null);
}
/// <summary>
/// Add a part type to the container. If the part type does not have any exports it
/// will be ignored.
/// </summary>
/// <typeparam name="TPart">The part type.</typeparam>
/// <param name="conventions">Conventions represented by a <see cref="AttributedModelProvider"/>, or null.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithPart<TPart>(AttributedModelProvider conventions)
{
return WithPart(typeof(TPart), conventions);
}
/// <summary>
/// Add part types to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="partTypes">The part types.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithParts(params Type[] partTypes)
{
return WithParts((IEnumerable<Type>)partTypes);
}
/// <summary>
/// Add part types to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="partTypes">The part types.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithParts(IEnumerable<Type> partTypes)
{
return WithParts(partTypes, null);
}
/// <summary>
/// Add part types to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="partTypes">The part types.</param>
/// <param name="conventions">Conventions represented by a <see cref="AttributedModelProvider"/>, or null.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithParts(IEnumerable<Type> partTypes!!, AttributedModelProvider conventions)
{
_types.Add(Tuple.Create(partTypes, conventions));
return this;
}
/// <summary>
/// Add part types from an assembly to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="assembly">The assembly from which to add part types.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithAssembly(Assembly assembly)
{
return WithAssembly(assembly, null);
}
/// <summary>
/// Add part types from an assembly to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="assembly">The assembly from which to add part types.</param>
/// <param name="conventions">Conventions represented by a <see cref="AttributedModelProvider"/>, or null.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithAssembly(Assembly assembly, AttributedModelProvider conventions)
{
return WithAssemblies(new[] { assembly }, conventions);
}
/// <summary>
/// Add part types from a list of assemblies to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="assemblies">Assemblies containing part types.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithAssemblies(IEnumerable<Assembly> assemblies)
{
return WithAssemblies(assemblies, null);
}
/// <summary>
/// Add part types from a list of assemblies to the container. If a part type does not have any exports it
/// will be ignored.
/// </summary>
/// <param name="assemblies">Assemblies containing part types.</param>
/// <param name="conventions">Conventions represented by a <see cref="AttributedModelProvider"/>, or null.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithAssemblies(IEnumerable<Assembly> assemblies!!, AttributedModelProvider conventions)
{
return WithParts(assemblies.SelectMany(a => a.DefinedTypes.Select(dt => dt.AsType())), conventions);
}
/// <summary>
/// Add a single instance to the container.
/// </summary>
/// <typeparam name="TExport">The type of the contract of the instance.</typeparam>
/// <param name="exportedInstance">The instance to add to the container.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithExport<TExport>(TExport exportedInstance!!)
{
return WithExport(exportedInstance, null, null);
}
/// <summary>
/// Add a single instance to the container.
/// </summary>
/// <typeparam name="TExport">The type of the contract of the instance.</typeparam>
/// <param name="exportedInstance">The instance to add to the container.</param>
/// <param name="contractName">Optionally, a name that discriminates this contract from others with the same type.</param>
/// <param name="metadata">Optionally, a non-empty collection of named constraints that apply to the contract.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithExport<TExport>(TExport exportedInstance!!, string contractName = null, IDictionary<string, object> metadata = null)
{
return WithExport(typeof(TExport), exportedInstance, contractName, metadata);
}
/// <summary>
/// Add a single instance to the container.
/// </summary>
/// <param name="contractType">The type of the contract of the instance.</param>
/// <param name="exportedInstance">The instance to add to the container.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithExport(Type contractType!!, object exportedInstance!!)
{
return WithExport(contractType, exportedInstance, null, null);
}
/// <summary>
/// Add a single instance to the container.
/// </summary>
/// <param name="contractType">The type of the contract of the instance.</param>
/// <param name="exportedInstance">The instance to add to the container.</param>
/// <param name="contractName">Optionally, a name that discriminates this contract from others with the same type.</param>
/// <param name="metadata">Optionally, a non-empty collection of named constraints that apply to the contract.</param>
/// <returns>A configuration object allowing configuration to continue.</returns>
public ContainerConfiguration WithExport(Type contractType!!, object exportedInstance!!, string contractName = null, IDictionary<string, object> metadata = null)
{
return WithProvider(new InstanceExportDescriptorProvider(exportedInstance, contractType, contractName, metadata));
}
internal ExportDescriptorProvider[] DebugGetAddedExportDescriptorProviders()
{
return _addedSources.ToArray();
}
internal Tuple<IEnumerable<Type>, AttributedModelProvider>[] DebugGetRegisteredTypes()
{
return _types.ToArray();
}
internal AttributedModelProvider DebugGetDefaultAttributeContext()
{
return _defaultAttributeContext;
}
}
}
| 1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Composition.TypedParts/tests/ContainerConfigurationTests.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Composition.Convention;
using System.Composition.Hosting.Core;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using Xunit;
namespace System.Composition.Hosting.Tests
{
public class ContainerConfigurationTests
{
[Fact]
public void WithProvider_ValidProvider_RegistersProvider()
{
var configuration = new ContainerConfiguration();
var provider = new ExportProvider { Result = 10 };
Assert.Same(configuration, configuration.WithProvider(provider));
CompositionHost container = configuration.CreateContainer();
Assert.Equal(0, provider.CalledGetExportDescriptors);
Assert.Equal(0, provider.CalledGetExportDescriptors);
Assert.Equal(10, container.GetExport<int>());
Assert.Equal(1, provider.CalledGetExportDescriptors);
Assert.Equal(1, provider.CalledGetExportDescriptors);
}
public class ExportProvider : ExportDescriptorProvider
{
public object Result { get; set; }
public int CalledGetExportDescriptors { get; set; }
public int CalledCompositeActivator { get; set; }
public override IEnumerable<ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor)
{
CalledGetExportDescriptors++;
return new[]
{
new ExportDescriptorPromise(contract, "origin", false, () => new CompositionDependency[0], dependencies => ExportDescriptor.Create(CompositeActivator, new Dictionary<string, object>()))
};
}
public object CompositeActivator(LifetimeContext context, CompositionOperation operation)
{
CalledCompositeActivator++;
return Result;
}
}
[Fact]
public void WithProvider_NullProvider_ThrowsArgumentNullException()
{
var configuration = new ContainerConfiguration();
AssertExtensions.Throws<ArgumentNullException>("exportDescriptorProvider", () => configuration.WithProvider(null));
}
[Fact]
public void WithDefaultConventions_PartWithNoMatchingConvention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
configuration.WithPart(typeof(ExportedProperty));
Assert.Same(configuration, configuration.WithDefaultConventions(conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithDefaultConventions_IEnumerablePartsWithNoMatchingConvention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
configuration.WithParts((IEnumerable<Type>)new Type[] { typeof(ExportedProperty) });
Assert.Same(configuration, configuration.WithDefaultConventions(conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithDefaultConventions_PartsArrayWithNoMatchingConvention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
configuration.WithParts(new Type[] { typeof(ExportedProperty) });
Assert.Same(configuration, configuration.WithDefaultConventions(conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithDefaultConventions_PartTNoMatchingConvention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
configuration.WithPart<ExportedProperty>();
Assert.Same(configuration, configuration.WithDefaultConventions(conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
public class ExportedProperty
{
[Export]
public string Property => "A";
}
[Fact]
public void WithDefaultConventions_NullConventions_ThrowsArgumentNullException()
{
var configuration = new ContainerConfiguration();
AssertExtensions.Throws<ArgumentNullException>("conventions", () => configuration.WithDefaultConventions(null));
}
[Fact]
public void WithDefaultConventions_AlreadyHasDefaultConventions_ThrowsInvalidOperationException()
{
var configuration = new ContainerConfiguration();
configuration.WithDefaultConventions(new ConventionBuilder());
Assert.Throws<InvalidOperationException>(() => configuration.WithDefaultConventions(new ConventionBuilder()));
}
[Fact]
public void WithPartT_Convention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithPart<ExportedProperty>(conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithPart_Convention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithPart(typeof(ExportedProperty), conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithPart_NullPartType_ThrowsArgumentNullException()
{
var configuration = new ContainerConfiguration();
AssertExtensions.Throws<ArgumentNullException>("partType", () => configuration.WithPart(null));
AssertExtensions.Throws<ArgumentNullException>("partType", () => configuration.WithPart(null, new ConventionBuilder()));
}
[Fact]
public void WithParts_Convention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithParts(new Type[] { typeof(ExportedProperty) }, conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithParts_NullPartTypes_ThrowsArgumentNullException()
{
var configuration = new ContainerConfiguration();
AssertExtensions.Throws<ArgumentNullException>("partTypes", () => configuration.WithParts(null));
AssertExtensions.Throws<ArgumentNullException>("partTypes", () => configuration.WithParts((IEnumerable<Type>)null));
AssertExtensions.Throws<ArgumentNullException>("partTypes", () => configuration.WithParts(null, new ConventionBuilder()));
}
[Fact]
public void WithParts_NullItemInPartTypes_ThrowsArgumentNullExceptionOnCreation()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(new Type[] { null });
AssertExtensions.Throws<ArgumentNullException>("type", () => configuration.CreateContainer());
}
[Fact]
public void WithAssembly_Assembly_ThrowsCompositionFailedExceptionOnCreation()
{
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithAssembly(typeof(ExportedProperty).Assembly));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Fact]
public void WithAssembly_AssemblyConventions_ThrowsCompositionFailedExceptionOnCreation()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithAssembly(typeof(ExportedProperty).Assembly, conventions));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Fact]
public void WithAssemblies_Assemblies_ThrowsCompositionFailedExceptionOnCreation()
{
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithAssemblies(new Assembly[] { typeof(ExportedProperty).Assembly }));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Fact]
public void WithAssemblies_AssembliesAndConvention_ThrowsCompositionFailedExceptionOnCreation()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithAssemblies(new Assembly[] { typeof(ExportedProperty).Assembly }, conventions));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Fact]
public void WithAssemblies_NullAssemblies_ThrowsArgumentNullException()
{
var configuration = new ContainerConfiguration();
AssertExtensions.Throws<ArgumentNullException>("assemblies", () => configuration.WithAssemblies(null));
AssertExtensions.Throws<ArgumentNullException>("assemblies", () => configuration.WithAssemblies(null, new ConventionBuilder()));
}
[Fact]
public void WithAssemby_Null_ThrowsNullReferenceExceptionOnCreation()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithAssembly(null);
Assert.Throws<NullReferenceException>(() => configuration.CreateContainer());
}
[Fact]
public void CreateContainer_ExportedSubClass_Success()
{
CompositionHost container = new ContainerConfiguration()
.WithPart(typeof(Derived))
.CreateContainer();
Assert.Equal("Derived", container.GetExport<Derived>().Prop);
}
[Export]
public class Derived : Base
{
public new string Prop { get; set; } = "Derived";
}
public class Base
{
public object Prop { get; set; } = "Derived";
}
[Fact]
public void CreateContainer_OpenGenericTypes_Success()
{
var conventions = new ConventionBuilder();
conventions.ForTypesDerivedFrom<IContainer>()
.Export<IContainer>();
conventions.ForTypesDerivedFrom(typeof(IRepository<>))
.Export(t => t.AsContractType(typeof(IRepository<>)));
CompositionHost container = new ContainerConfiguration()
.WithParts(new Type[] { typeof(EFRepository<>), typeof(Container) }, conventions)
.CreateContainer();
Assert.Equal(0, container.GetExport<IRepository<int>>().Fetch());
}
public interface IContainer { }
public class Container : IContainer { }
public interface IRepository<T>
{
T Fetch();
}
public class EFRepository<T> : IRepository<T>
{
public EFRepository(IContainer test) { }
public T Fetch() => default(T);
}
[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsReflectionEmitSupported))]
public void CreateContainer_ImportConventionsWithInheritedProperties_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<Imported>().Export();
conventions.ForType<DerivedFromBaseWithImport>()
.ImportProperty(b => b.Imported)
.Export();
CompositionHost container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(Imported), typeof(DerivedFromBaseWithImport))
.CreateContainer();
DerivedFromBaseWithImport export = container.GetExport<DerivedFromBaseWithImport>();
Assert.IsAssignableFrom<Imported>(export.Imported);
}
public class Imported { }
public class BaseWithImport
{
public virtual Imported Imported { get; set; }
}
public class DerivedFromBaseWithImport : BaseWithImport { }
[Fact]
public void CreateContainer_ExportConventionsWithInheritedProperties_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<DerivedFromBaseWithExport>()
.ExportProperty(b => b.Exported);
CompositionHost container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(DerivedFromBaseWithExport))
.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
public class BaseWithExport
{
public string Exported { get { return "A"; } }
}
public class DerivedFromBaseWithExport : BaseWithExport { }
[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsReflectionEmitSupported))]
public void CreateContainer_ExportsToInheritedProperties_DontInterfereWithBase()
{
var conventions = new ConventionBuilder();
conventions.ForType<DerivedFromBaseWithExport2>()
.ExportProperty(b => b.Exported);
CompositionHost container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(BaseWithExport2))
.WithParts(typeof(DerivedFromBaseWithExport2))
.CreateContainer();
Assert.Equal(new string[] { "A", "A" }, container.GetExports<string>());
}
public class BaseWithExport2
{
[Export]
public virtual string Exported => "A";
}
public class DerivedFromBaseWithExport2 : BaseWithExport { }
[Fact]
public void CreateContainer_HasConventions_ClassExportsAreNotInherited()
{
CompositionHost container = new ContainerConfiguration()
.WithPart<DerivedFromBaseWithDeclaredExports>(new ConventionBuilder())
.CreateContainer();
Assert.False(container.TryGetExport(out BaseWithDeclaredExports export));
}
[Fact]
public void CreateContainer_HasConventions_PropertyExportsAreNotInherited()
{
CompositionHost container = new ContainerConfiguration()
.WithPart<DerivedFromBaseWithDeclaredExports>(new ConventionBuilder())
.CreateContainer();
Assert.False(container.TryGetExport(out string export));
}
[Export]
public class BaseWithDeclaredExports
{
public BaseWithDeclaredExports() => Property = "foo";
[Export]
public string Property { get; set; }
}
public class DerivedFromBaseWithDeclaredExports : BaseWithDeclaredExports { }
public class CustomExport : ExportAttribute { }
[Fact]
public void CreateContainer_HasConventions_CustomAttributesAreNotInherited()
{
CompositionHost container = new ContainerConfiguration()
.WithPart<DerivedFromBaseWithCustomExport>(new ConventionBuilder())
.CreateContainer();
Assert.False(container.TryGetExport(out BaseWithCustomExport bce));
}
[CustomExport]
public class BaseWithCustomExport { }
public class DerivedFromBaseWithCustomExport : BaseWithCustomExport { }
[Fact]
public void CreateContainer_OpenGenericTypePart_Success()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(typeof(GenericExportedType<>));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("C", container.GetExport<GenericExportedType<int>>().Property);
}
[Export(typeof(GenericExportedType<>))]
public class GenericExportedType<T>
{
public string Property => "C";
}
[Theory]
[InlineData(typeof(IncompatibleGenericExportedType<>))]
[InlineData(typeof(IncompatibleGenericExportedType<int>))]
[InlineData(typeof(IncompatibleGenericExportedTypeDerived<>))]
public void CreateContainer_GenericTypeExport_ThrowsCompositionFailedException(Type partType)
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(partType);
Assert.Throws<CompositionFailedException>( () => configuration.CreateContainer());
}
[Export(typeof(GenericExportedType<>))]
public class IncompatibleGenericExportedType<T> { }
[Export(typeof(GenericExportedType<>))]
public class IncompatibleGenericExportedTypeDerived<T> : GenericExportedType<int> { }
[Theory]
[InlineData(typeof(NonGenericExportedType<>))]
[InlineData(typeof(NonGenericExportedType<int>))]
public void CreateContainer_NonGenericTypeExportWithGenericPart_ThrowsCompositionFailedException(Type partType)
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(partType);
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Export(typeof(string))]
public class NonGenericExportedType<T> { }
[Fact]
public void CreateContainer_UnassignableType_ThrowsCompositionFailedException()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(typeof(ContractExportedType));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Export(typeof(Derived))]
public class ContractExportedType { }
[Fact]
public void CreateContainer_AbstractOrStructType_Success()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(typeof(AbstractClass), typeof(StructType));
CompositionHost container = configuration.CreateContainer();
Assert.Throws<CompositionFailedException>(() => container.GetExport<AbstractClass>());
Assert.Throws<CompositionFailedException>(() => container.GetExport<StructType>());
}
public abstract class AbstractClass { }
public struct StructType { }
[Fact]
public void CreateContainer_MetadataProperty_Success()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithPart(typeof(MetadataProperty));
CompositionHost container = configuration.CreateContainer();
Assert.Throws<CompositionFailedException>(() => container.GetExport<MetadataProperty>());
}
[MetadataAttribute]
public class CustomMetadataExportAttribute : ExportAttribute
{
public object NullName { get; set; } = null;
public string StringName { get; set; } = "value";
public int[] ArrayName { get; set; } = new int[] { 1, 2, 3 };
}
public class MetadataProperty
{
[CustomMetadataExport]
[ExportMetadata("NullName", null)]
public object NullMetadata { get; set; }
[CustomMetadataExport]
[ExportMetadata("StringName", "value")]
public string StringMetadata { get; set; }
[CustomMetadataExport]
[ExportMetadata("ArrayName", 4)]
public int[] ArrayMetadata { get; set; }
[CustomMetadataExport]
[ExportMetadata("NewName", 1)]
[Required]
public int NewMetadata { get; set; }
}
[Fact]
public void CreateContainer_MetadataClass_Success()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithPart(typeof(MetadataClass));
CompositionHost container = configuration.CreateContainer();
Assert.Throws<CompositionFailedException>(() => container.GetExport<MetadataProperty>());
}
[CustomMetadataExport]
public class MetadataClass { }
[Fact]
public void CreateContainer_ExportIncompatibleNonGenericProperty_ThrowsCompositionFailedException()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithPart(typeof(IncompatibleExportProperty));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
public class IncompatibleExportProperty
{
[Export(typeof(int))]
public string Property { get; set; }
}
[Fact]
public void CreateContainer_ExportGenericProperty_Success()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithPart(typeof(GenericExportProperty<>));
Assert.NotNull(configuration.CreateContainer());
}
public class GenericExportProperty<T>
{
[Export(typeof(List<>))]
public List<T> Property { get; set; } = new List<T>();
}
[Fact]
public void CreateContainer_ExportIncompatibleGenericProperty_ThrowsCompositionFailedException()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithPart(typeof(IncompatibleGenericExportProperty<>));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
public class IncompatibleGenericExportProperty<T>
{
[Export(typeof(List<string>))]
public List<T> Property { get; set; }
}
public static IEnumerable<object[]> DebuggerAttributes_TestData()
{
yield return new object[] { new ContainerConfiguration() };
yield return new object[] { new ContainerConfiguration().WithPart(typeof(int)) };
yield return new object[] { new ContainerConfiguration().WithDefaultConventions(new ConventionBuilder()).WithPart(typeof(int)) };
yield return new object[] { new ContainerConfiguration().WithPart(typeof(int), new ConventionBuilder()) };
yield return new object[] { new ContainerConfiguration().WithPart(typeof(ExportedProperty)) };
}
[Theory]
[MemberData(nameof(DebuggerAttributes_TestData))]
public void DebuggerAttributes_GetViaReflection_Success(ContainerConfiguration configuration)
{
DebuggerAttributeInfo debuggerAttributeInfo = DebuggerAttributes.ValidateDebuggerTypeProxyProperties(configuration);
foreach (PropertyInfo property in debuggerAttributeInfo.Properties)
{
Assert.NotNull(property.GetValue(debuggerAttributeInfo.Instance));
}
}
[Fact]
public void CreateContiner_GenericExportWithDependencyConstructorHasConvention_Success()
{
var conventions = new ConventionBuilder();
conventions
.ForType<Dependency>()
.Export<Dependency>();
conventions
.ForType(typeof(MoreOpenWithDependency<>))
.ExportInterfaces(
(i) => i.GetGenericTypeDefinition() == typeof(IOpen<>),
(type, builder) => builder.AsContractType(typeof(IOpen<>)))
.SelectConstructor(ctors => ctors.ElementAt(0));
var configuration = new ContainerConfiguration()
.WithParts(new[] { typeof(IOpen<>), typeof(MoreOpenWithDependency<>), typeof(Dependency) }, conventions);
using (var container = configuration.CreateContainer())
{
var service = container.GetExport(typeof(IOpen<object>)) as MoreOpenWithDependency<object>;
Assert.NotNull(service);
Assert.NotNull(service.Dependency);
}
}
public interface IOpen<T>
{
}
public class MoreOpenWithDependency<T> : IOpen<T>
{
public Dependency Dependency { get; set; }
public MoreOpenWithDependency(Dependency dep)
{
Dependency = dep;
}
}
public class Dependency { }
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Composition.Convention;
using System.Composition.Hosting.Core;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using Xunit;
namespace System.Composition.Hosting.Tests
{
public class ContainerConfigurationTests
{
[Fact]
public void WithProvider_ValidProvider_RegistersProvider()
{
var configuration = new ContainerConfiguration();
var provider = new ExportProvider { Result = 10 };
Assert.Same(configuration, configuration.WithProvider(provider));
CompositionHost container = configuration.CreateContainer();
Assert.Equal(0, provider.CalledGetExportDescriptors);
Assert.Equal(0, provider.CalledGetExportDescriptors);
Assert.Equal(10, container.GetExport<int>());
Assert.Equal(1, provider.CalledGetExportDescriptors);
Assert.Equal(1, provider.CalledGetExportDescriptors);
}
public class ExportProvider : ExportDescriptorProvider
{
public object Result { get; set; }
public int CalledGetExportDescriptors { get; set; }
public int CalledCompositeActivator { get; set; }
public override IEnumerable<ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor)
{
CalledGetExportDescriptors++;
return new[]
{
new ExportDescriptorPromise(contract, "origin", false, () => new CompositionDependency[0], dependencies => ExportDescriptor.Create(CompositeActivator, new Dictionary<string, object>()))
};
}
public object CompositeActivator(LifetimeContext context, CompositionOperation operation)
{
CalledCompositeActivator++;
return Result;
}
}
[Fact]
public void WithProvider_NullProvider_ThrowsArgumentNullException()
{
var configuration = new ContainerConfiguration();
AssertExtensions.Throws<ArgumentNullException>("exportDescriptorProvider", () => configuration.WithProvider(null));
}
[Fact]
public void WithDefaultConventions_PartWithNoMatchingConvention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
configuration.WithPart(typeof(ExportedProperty));
Assert.Same(configuration, configuration.WithDefaultConventions(conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithDefaultConventions_IEnumerablePartsWithNoMatchingConvention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
configuration.WithParts((IEnumerable<Type>)new Type[] { typeof(ExportedProperty) });
Assert.Same(configuration, configuration.WithDefaultConventions(conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithDefaultConventions_PartsArrayWithNoMatchingConvention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
configuration.WithParts(new Type[] { typeof(ExportedProperty) });
Assert.Same(configuration, configuration.WithDefaultConventions(conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithDefaultConventions_PartTNoMatchingConvention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
configuration.WithPart<ExportedProperty>();
Assert.Same(configuration, configuration.WithDefaultConventions(conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
public class ExportedProperty
{
[Export]
public string Property => "A";
}
[Fact]
public void WithDefaultConventions_NullConventions_ThrowsArgumentNullException()
{
var configuration = new ContainerConfiguration();
AssertExtensions.Throws<ArgumentNullException>("conventions", () => configuration.WithDefaultConventions(null));
}
[Fact]
public void WithDefaultConventions_AlreadyHasDefaultConventions_ThrowsInvalidOperationException()
{
var configuration = new ContainerConfiguration();
configuration.WithDefaultConventions(new ConventionBuilder());
Assert.Throws<InvalidOperationException>(() => configuration.WithDefaultConventions(new ConventionBuilder()));
}
[Fact]
public void WithPartT_Convention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithPart<ExportedProperty>(conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithPart_Convention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithPart(typeof(ExportedProperty), conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithPart_NullPartType_ThrowsArgumentNullException()
{
var configuration = new ContainerConfiguration();
AssertExtensions.Throws<ArgumentNullException>("partType", () => configuration.WithPart(null));
AssertExtensions.Throws<ArgumentNullException>("partType", () => configuration.WithPart(null, new ConventionBuilder()));
}
[Fact]
public void WithParts_Convention_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithParts(new Type[] { typeof(ExportedProperty) }, conventions));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
[Fact]
public void WithParts_NullPartTypes_ThrowsArgumentNullException()
{
var configuration = new ContainerConfiguration();
AssertExtensions.Throws<ArgumentNullException>("partTypes", () => configuration.WithParts(null));
AssertExtensions.Throws<ArgumentNullException>("partTypes", () => configuration.WithParts((IEnumerable<Type>)null));
AssertExtensions.Throws<ArgumentNullException>("partTypes", () => configuration.WithParts(null, new ConventionBuilder()));
}
[Fact]
public void WithParts_NullItemInPartTypes_ThrowsArgumentNullExceptionOnCreation()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(new Type[] { null });
AssertExtensions.Throws<ArgumentNullException>("type", () => configuration.CreateContainer());
}
[Fact]
public void WithAssembly_Assembly_ThrowsCompositionFailedExceptionOnCreation()
{
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithAssembly(typeof(ExportedProperty).Assembly));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Fact]
public void WithAssembly_AssemblyConventions_ThrowsCompositionFailedExceptionOnCreation()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithAssembly(typeof(ExportedProperty).Assembly, conventions));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Fact]
public void WithAssemblies_Assemblies_ThrowsCompositionFailedExceptionOnCreation()
{
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithAssemblies(new Assembly[] { typeof(ExportedProperty).Assembly }));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Fact]
public void WithAssemblies_AssembliesAndConvention_ThrowsCompositionFailedExceptionOnCreation()
{
var conventions = new ConventionBuilder();
conventions.ForType<ExportedProperty>().ExportProperty(b => b.Property);
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithAssemblies(new Assembly[] { typeof(ExportedProperty).Assembly }, conventions));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Fact]
public void WithAssemblies_NullAssemblies_ThrowsArgumentNullException()
{
var configuration = new ContainerConfiguration();
AssertExtensions.Throws<ArgumentNullException>("assemblies", () => configuration.WithAssemblies(null));
AssertExtensions.Throws<ArgumentNullException>("assemblies", () => configuration.WithAssemblies(null, new ConventionBuilder()));
}
[Fact]
public void WithAssemby_Null_ThrowsNullReferenceExceptionOnCreation()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithAssembly(null);
Assert.Throws<NullReferenceException>(() => configuration.CreateContainer());
}
[Fact]
public void WithExport_Base_Success()
{
var instance = new Base();
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithExport<Base>(instance));
CompositionHost container = configuration.CreateContainer();
Assert.Same(instance, container.GetExport<Base>());
}
[Fact]
public void WithExport_Derived_Success()
{
var instance = new Derived();
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithExport<Base>(instance));
CompositionHost container = configuration.CreateContainer();
Assert.Same(instance, container.GetExport<Base>());
}
[Fact]
public void WithExport_ContractName_Success()
{
var instance = new Base();
var configuration = new ContainerConfiguration();
Assert.Same(configuration, configuration.WithExport<Base>(instance, "Contract"));
CompositionHost container = configuration.CreateContainer();
Assert.Same(instance, container.GetExport<Base>("Contract"));
}
[Fact]
public void CreateContainer_ExportedSubClass_Success()
{
CompositionHost container = new ContainerConfiguration()
.WithPart(typeof(Derived))
.CreateContainer();
Assert.Equal("Derived", container.GetExport<Derived>().Prop);
}
[Export]
public class Derived : Base
{
public new string Prop { get; set; } = "Derived";
}
public class Base
{
public object Prop { get; set; } = "Derived";
}
[Fact]
public void CreateContainer_OpenGenericTypes_Success()
{
var conventions = new ConventionBuilder();
conventions.ForTypesDerivedFrom<IContainer>()
.Export<IContainer>();
conventions.ForTypesDerivedFrom(typeof(IRepository<>))
.Export(t => t.AsContractType(typeof(IRepository<>)));
CompositionHost container = new ContainerConfiguration()
.WithParts(new Type[] { typeof(EFRepository<>), typeof(Container) }, conventions)
.CreateContainer();
Assert.Equal(0, container.GetExport<IRepository<int>>().Fetch());
}
public interface IContainer { }
public class Container : IContainer { }
public interface IRepository<T>
{
T Fetch();
}
public class EFRepository<T> : IRepository<T>
{
public EFRepository(IContainer test) { }
public T Fetch() => default(T);
}
[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsReflectionEmitSupported))]
public void CreateContainer_ImportConventionsWithInheritedProperties_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<Imported>().Export();
conventions.ForType<DerivedFromBaseWithImport>()
.ImportProperty(b => b.Imported)
.Export();
CompositionHost container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(Imported), typeof(DerivedFromBaseWithImport))
.CreateContainer();
DerivedFromBaseWithImport export = container.GetExport<DerivedFromBaseWithImport>();
Assert.IsAssignableFrom<Imported>(export.Imported);
}
public class Imported { }
public class BaseWithImport
{
public virtual Imported Imported { get; set; }
}
public class DerivedFromBaseWithImport : BaseWithImport { }
[Fact]
public void CreateContainer_ExportConventionsWithInheritedProperties_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType<DerivedFromBaseWithExport>()
.ExportProperty(b => b.Exported);
CompositionHost container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(DerivedFromBaseWithExport))
.CreateContainer();
Assert.Equal("A", container.GetExport<string>());
}
public class BaseWithExport
{
public string Exported { get { return "A"; } }
}
public class DerivedFromBaseWithExport : BaseWithExport { }
[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsReflectionEmitSupported))]
public void CreateContainer_ExportsToInheritedProperties_DontInterfereWithBase()
{
var conventions = new ConventionBuilder();
conventions.ForType<DerivedFromBaseWithExport2>()
.ExportProperty(b => b.Exported);
CompositionHost container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(BaseWithExport2))
.WithParts(typeof(DerivedFromBaseWithExport2))
.CreateContainer();
Assert.Equal(new string[] { "A", "A" }, container.GetExports<string>());
}
public class BaseWithExport2
{
[Export]
public virtual string Exported => "A";
}
public class DerivedFromBaseWithExport2 : BaseWithExport { }
[Fact]
public void CreateContainer_HasConventions_ClassExportsAreNotInherited()
{
CompositionHost container = new ContainerConfiguration()
.WithPart<DerivedFromBaseWithDeclaredExports>(new ConventionBuilder())
.CreateContainer();
Assert.False(container.TryGetExport(out BaseWithDeclaredExports export));
}
[Fact]
public void CreateContainer_HasConventions_PropertyExportsAreNotInherited()
{
CompositionHost container = new ContainerConfiguration()
.WithPart<DerivedFromBaseWithDeclaredExports>(new ConventionBuilder())
.CreateContainer();
Assert.False(container.TryGetExport(out string export));
}
[Export]
public class BaseWithDeclaredExports
{
public BaseWithDeclaredExports() => Property = "foo";
[Export]
public string Property { get; set; }
}
public class DerivedFromBaseWithDeclaredExports : BaseWithDeclaredExports { }
public class CustomExport : ExportAttribute { }
[Fact]
public void CreateContainer_HasConventions_CustomAttributesAreNotInherited()
{
CompositionHost container = new ContainerConfiguration()
.WithPart<DerivedFromBaseWithCustomExport>(new ConventionBuilder())
.CreateContainer();
Assert.False(container.TryGetExport(out BaseWithCustomExport bce));
}
[CustomExport]
public class BaseWithCustomExport { }
public class DerivedFromBaseWithCustomExport : BaseWithCustomExport { }
[Fact]
public void CreateContainer_OpenGenericTypePart_Success()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(typeof(GenericExportedType<>));
CompositionHost container = configuration.CreateContainer();
Assert.Equal("C", container.GetExport<GenericExportedType<int>>().Property);
}
[Export(typeof(GenericExportedType<>))]
public class GenericExportedType<T>
{
public string Property => "C";
}
[Theory]
[InlineData(typeof(IncompatibleGenericExportedType<>))]
[InlineData(typeof(IncompatibleGenericExportedType<int>))]
[InlineData(typeof(IncompatibleGenericExportedTypeDerived<>))]
public void CreateContainer_GenericTypeExport_ThrowsCompositionFailedException(Type partType)
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(partType);
Assert.Throws<CompositionFailedException>( () => configuration.CreateContainer());
}
[Export(typeof(GenericExportedType<>))]
public class IncompatibleGenericExportedType<T> { }
[Export(typeof(GenericExportedType<>))]
public class IncompatibleGenericExportedTypeDerived<T> : GenericExportedType<int> { }
[Theory]
[InlineData(typeof(NonGenericExportedType<>))]
[InlineData(typeof(NonGenericExportedType<int>))]
public void CreateContainer_NonGenericTypeExportWithGenericPart_ThrowsCompositionFailedException(Type partType)
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(partType);
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Export(typeof(string))]
public class NonGenericExportedType<T> { }
[Fact]
public void CreateContainer_UnassignableType_ThrowsCompositionFailedException()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(typeof(ContractExportedType));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
[Export(typeof(Derived))]
public class ContractExportedType { }
[Fact]
public void CreateContainer_AbstractOrStructType_Success()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithParts(typeof(AbstractClass), typeof(StructType));
CompositionHost container = configuration.CreateContainer();
Assert.Throws<CompositionFailedException>(() => container.GetExport<AbstractClass>());
Assert.Throws<CompositionFailedException>(() => container.GetExport<StructType>());
}
public abstract class AbstractClass { }
public struct StructType { }
[Fact]
public void CreateContainer_MetadataProperty_Success()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithPart(typeof(MetadataProperty));
CompositionHost container = configuration.CreateContainer();
Assert.Throws<CompositionFailedException>(() => container.GetExport<MetadataProperty>());
}
[MetadataAttribute]
public class CustomMetadataExportAttribute : ExportAttribute
{
public object NullName { get; set; } = null;
public string StringName { get; set; } = "value";
public int[] ArrayName { get; set; } = new int[] { 1, 2, 3 };
}
public class MetadataProperty
{
[CustomMetadataExport]
[ExportMetadata("NullName", null)]
public object NullMetadata { get; set; }
[CustomMetadataExport]
[ExportMetadata("StringName", "value")]
public string StringMetadata { get; set; }
[CustomMetadataExport]
[ExportMetadata("ArrayName", 4)]
public int[] ArrayMetadata { get; set; }
[CustomMetadataExport]
[ExportMetadata("NewName", 1)]
[Required]
public int NewMetadata { get; set; }
}
[Fact]
public void CreateContainer_MetadataClass_Success()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithPart(typeof(MetadataClass));
CompositionHost container = configuration.CreateContainer();
Assert.Throws<CompositionFailedException>(() => container.GetExport<MetadataProperty>());
}
[CustomMetadataExport]
public class MetadataClass { }
[Fact]
public void CreateContainer_ExportIncompatibleNonGenericProperty_ThrowsCompositionFailedException()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithPart(typeof(IncompatibleExportProperty));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
public class IncompatibleExportProperty
{
[Export(typeof(int))]
public string Property { get; set; }
}
[Fact]
public void CreateContainer_ExportGenericProperty_Success()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithPart(typeof(GenericExportProperty<>));
Assert.NotNull(configuration.CreateContainer());
}
public class GenericExportProperty<T>
{
[Export(typeof(List<>))]
public List<T> Property { get; set; } = new List<T>();
}
[Fact]
public void CreateContainer_ExportIncompatibleGenericProperty_ThrowsCompositionFailedException()
{
ContainerConfiguration configuration = new ContainerConfiguration().WithPart(typeof(IncompatibleGenericExportProperty<>));
Assert.Throws<CompositionFailedException>(() => configuration.CreateContainer());
}
public class IncompatibleGenericExportProperty<T>
{
[Export(typeof(List<string>))]
public List<T> Property { get; set; }
}
public static IEnumerable<object[]> DebuggerAttributes_TestData()
{
yield return new object[] { new ContainerConfiguration() };
yield return new object[] { new ContainerConfiguration().WithPart(typeof(int)) };
yield return new object[] { new ContainerConfiguration().WithDefaultConventions(new ConventionBuilder()).WithPart(typeof(int)) };
yield return new object[] { new ContainerConfiguration().WithPart(typeof(int), new ConventionBuilder()) };
yield return new object[] { new ContainerConfiguration().WithPart(typeof(ExportedProperty)) };
}
[Theory]
[MemberData(nameof(DebuggerAttributes_TestData))]
public void DebuggerAttributes_GetViaReflection_Success(ContainerConfiguration configuration)
{
DebuggerAttributeInfo debuggerAttributeInfo = DebuggerAttributes.ValidateDebuggerTypeProxyProperties(configuration);
foreach (PropertyInfo property in debuggerAttributeInfo.Properties)
{
Assert.NotNull(property.GetValue(debuggerAttributeInfo.Instance));
}
}
[Fact]
public void CreateContiner_GenericExportWithDependencyConstructorHasConvention_Success()
{
var conventions = new ConventionBuilder();
conventions
.ForType<Dependency>()
.Export<Dependency>();
conventions
.ForType(typeof(MoreOpenWithDependency<>))
.ExportInterfaces(
(i) => i.GetGenericTypeDefinition() == typeof(IOpen<>),
(type, builder) => builder.AsContractType(typeof(IOpen<>)))
.SelectConstructor(ctors => ctors.ElementAt(0));
var configuration = new ContainerConfiguration()
.WithParts(new[] { typeof(IOpen<>), typeof(MoreOpenWithDependency<>), typeof(Dependency) }, conventions);
using (var container = configuration.CreateContainer())
{
var service = container.GetExport(typeof(IOpen<object>)) as MoreOpenWithDependency<object>;
Assert.NotNull(service);
Assert.NotNull(service.Dependency);
}
}
public interface IOpen<T>
{
}
public class MoreOpenWithDependency<T> : IOpen<T>
{
public Dependency Dependency { get; set; }
public MoreOpenWithDependency(Dependency dep)
{
Dependency = dep;
}
}
public class Dependency { }
}
}
| 1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/TypeInfos/RuntimeConstructedGenericTypeInfo.UnificationKey.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Reflection;
using System.Diagnostics;
using System.Collections.Generic;
using System.Collections.Concurrent;
namespace System.Reflection.Runtime.TypeInfos
{
internal sealed partial class RuntimeConstructedGenericTypeInfo : RuntimeTypeInfo, IKeyedItem<RuntimeConstructedGenericTypeInfo.UnificationKey>
{
//
// Key for unification.
//
internal struct UnificationKey : IEquatable<UnificationKey>
{
//
// Q: Why is the type handle part of the unification key when it doesn't participate in the Equals/HashCode computations?
// A: It's a passenger.
//
// The typeHandle argument is "redundant" in that it can be computed from the rest of the key. However, we have callers (Type.GetTypeFromHandle()) that
// already have the typeHandle so to avoid an unnecessary round-trip computation, we require the caller to pass it in separately.
// We allow it to ride along in the key object because the ConcurrentUnifier classes we use don't support passing "extra" parameters to
// their Factory methods.
//
public UnificationKey(RuntimeTypeInfo genericTypeDefinition, RuntimeTypeInfo[] genericTypeArguments, RuntimeTypeHandle typeHandle)
{
GenericTypeDefinition = genericTypeDefinition;
GenericTypeArguments = genericTypeArguments;
TypeHandle = typeHandle;
}
public RuntimeTypeInfo GenericTypeDefinition { get; }
public RuntimeTypeInfo[] GenericTypeArguments { get; }
public RuntimeTypeHandle TypeHandle { get; }
public override bool Equals(object obj)
{
if (!(obj is UnificationKey other))
return false;
return Equals(other);
}
public bool Equals(UnificationKey other)
{
if (!GenericTypeDefinition.Equals(other.GenericTypeDefinition))
return false;
if (GenericTypeArguments.Length != other.GenericTypeArguments.Length)
return false;
for (int i = 0; i < GenericTypeArguments.Length; i++)
{
if (!(GenericTypeArguments[i].Equals(other.GenericTypeArguments[i])))
return false;
}
// The TypeHandle is not actually part of the key but riding along for convenience (see commment at head of class.)
// If the other parts of the key matched, this must too.
Debug.Assert(TypeHandle.Equals(other.TypeHandle));
return true;
}
public override int GetHashCode()
{
int hashCode = GenericTypeDefinition.GetHashCode();
for (int i = 0; i < GenericTypeArguments.Length; i++)
{
hashCode ^= GenericTypeArguments[i].GetHashCode();
}
return hashCode;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Reflection;
using System.Diagnostics;
using System.Collections.Generic;
using System.Collections.Concurrent;
namespace System.Reflection.Runtime.TypeInfos
{
internal sealed partial class RuntimeConstructedGenericTypeInfo : RuntimeTypeInfo, IKeyedItem<RuntimeConstructedGenericTypeInfo.UnificationKey>
{
//
// Key for unification.
//
internal struct UnificationKey : IEquatable<UnificationKey>
{
//
// Q: Why is the type handle part of the unification key when it doesn't participate in the Equals/HashCode computations?
// A: It's a passenger.
//
// The typeHandle argument is "redundant" in that it can be computed from the rest of the key. However, we have callers (Type.GetTypeFromHandle()) that
// already have the typeHandle so to avoid an unnecessary round-trip computation, we require the caller to pass it in separately.
// We allow it to ride along in the key object because the ConcurrentUnifier classes we use don't support passing "extra" parameters to
// their Factory methods.
//
public UnificationKey(RuntimeTypeInfo genericTypeDefinition, RuntimeTypeInfo[] genericTypeArguments, RuntimeTypeHandle typeHandle)
{
GenericTypeDefinition = genericTypeDefinition;
GenericTypeArguments = genericTypeArguments;
TypeHandle = typeHandle;
}
public RuntimeTypeInfo GenericTypeDefinition { get; }
public RuntimeTypeInfo[] GenericTypeArguments { get; }
public RuntimeTypeHandle TypeHandle { get; }
public override bool Equals(object obj)
{
if (!(obj is UnificationKey other))
return false;
return Equals(other);
}
public bool Equals(UnificationKey other)
{
if (!GenericTypeDefinition.Equals(other.GenericTypeDefinition))
return false;
if (GenericTypeArguments.Length != other.GenericTypeArguments.Length)
return false;
for (int i = 0; i < GenericTypeArguments.Length; i++)
{
if (!(GenericTypeArguments[i].Equals(other.GenericTypeArguments[i])))
return false;
}
// The TypeHandle is not actually part of the key but riding along for convenience (see commment at head of class.)
// If the other parts of the key matched, this must too.
Debug.Assert(TypeHandle.Equals(other.TypeHandle));
return true;
}
public override int GetHashCode()
{
int hashCode = GenericTypeDefinition.GetHashCode();
for (int i = 0; i < GenericTypeArguments.Length; i++)
{
hashCode ^= GenericTypeArguments[i].GetHashCode();
}
return hashCode;
}
}
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/coreclr/tools/Common/TypeSystem/Common/TypeSystemException.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Collections.Generic;
namespace Internal.TypeSystem
{
/// <summary>
/// Base type for all type system exceptions.
/// </summary>
public abstract partial class TypeSystemException : Exception
{
private string[] _arguments;
/// <summary>
/// Gets the resource string identifier.
/// </summary>
public ExceptionStringID StringID { get; }
/// <summary>
/// Gets the formatting arguments for the exception string.
/// </summary>
public IReadOnlyList<string> Arguments
{
get
{
return _arguments;
}
}
public override string Message
{
get
{
return GetExceptionString(StringID, _arguments);
}
}
internal TypeSystemException(ExceptionStringID id, params string[] args)
{
StringID = id;
_arguments = args;
}
private static string GetExceptionString(ExceptionStringID id, string[] args)
{
string formatString = GetFormatString(id);
try
{
if (formatString != null)
{
return String.Format(formatString, (object[])args);
}
}
catch {}
return "[TEMPORARY EXCEPTION MESSAGE] " + id.ToString() + ": " + String.Join(", ", args);
}
/// <summary>
/// The exception that is thrown when type-loading failures occur.
/// </summary>
public class TypeLoadException : TypeSystemException
{
public string TypeName { get; }
public string AssemblyName { get; }
internal TypeLoadException(ExceptionStringID id, string typeName, string assemblyName, string messageArg)
: base(id, new string[] { typeName, assemblyName, messageArg })
{
TypeName = typeName;
AssemblyName = assemblyName;
}
internal TypeLoadException(ExceptionStringID id, string typeName, string assemblyName)
: base(id, new string[] { typeName, assemblyName })
{
TypeName = typeName;
AssemblyName = assemblyName;
}
}
/// <summary>
/// The exception that is thrown when there is an attempt to access a class member that does not exist
/// or that is not declared as public.
/// </summary>
public abstract class MissingMemberException : TypeSystemException
{
protected internal MissingMemberException(ExceptionStringID id, params string[] args)
: base(id, args)
{
}
}
/// <summary>
/// The exception that is thrown when there is an attempt to access a method that does not exist.
/// </summary>
public class MissingMethodException : MissingMemberException
{
internal MissingMethodException(ExceptionStringID id, params string[] args)
: base(id, args)
{
}
}
/// <summary>
/// The exception that is thrown when there is an attempt to access a field that does not exist.
/// </summary>
public class MissingFieldException : MissingMemberException
{
internal MissingFieldException(ExceptionStringID id, params string[] args)
: base(id, args)
{
}
}
/// <summary>
/// The exception that is thrown when an attempt to access a file that does not exist on disk fails.
/// </summary>
public class FileNotFoundException : TypeSystemException
{
internal FileNotFoundException(ExceptionStringID id, string fileName)
: base(id, fileName)
{
}
}
/// <summary>
/// The exception that is thrown when a program contains invalid Microsoft intermediate language (MSIL) or metadata.
/// Generally this indicates a bug in the compiler that generated the program.
/// </summary>
public class InvalidProgramException : TypeSystemException
{
internal InvalidProgramException(ExceptionStringID id, string method)
: base(id, method)
{
}
internal InvalidProgramException(ExceptionStringID id)
: base(id)
{
}
internal InvalidProgramException()
: base(ExceptionStringID.InvalidProgramDefault)
{
}
}
public class BadImageFormatException : TypeSystemException
{
internal BadImageFormatException()
: base(ExceptionStringID.BadImageFormatGeneric)
{
}
internal BadImageFormatException(string reason)
: base(ExceptionStringID.BadImageFormatSpecific, reason)
{
}
}
public class MarshalDirectiveException : TypeSystemException
{
internal MarshalDirectiveException(ExceptionStringID id)
: base(id)
{
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Collections.Generic;
namespace Internal.TypeSystem
{
/// <summary>
/// Base type for all type system exceptions.
/// </summary>
public abstract partial class TypeSystemException : Exception
{
private string[] _arguments;
/// <summary>
/// Gets the resource string identifier.
/// </summary>
public ExceptionStringID StringID { get; }
/// <summary>
/// Gets the formatting arguments for the exception string.
/// </summary>
public IReadOnlyList<string> Arguments
{
get
{
return _arguments;
}
}
public override string Message
{
get
{
return GetExceptionString(StringID, _arguments);
}
}
internal TypeSystemException(ExceptionStringID id, params string[] args)
{
StringID = id;
_arguments = args;
}
private static string GetExceptionString(ExceptionStringID id, string[] args)
{
string formatString = GetFormatString(id);
try
{
if (formatString != null)
{
return String.Format(formatString, (object[])args);
}
}
catch {}
return "[TEMPORARY EXCEPTION MESSAGE] " + id.ToString() + ": " + String.Join(", ", args);
}
/// <summary>
/// The exception that is thrown when type-loading failures occur.
/// </summary>
public class TypeLoadException : TypeSystemException
{
public string TypeName { get; }
public string AssemblyName { get; }
internal TypeLoadException(ExceptionStringID id, string typeName, string assemblyName, string messageArg)
: base(id, new string[] { typeName, assemblyName, messageArg })
{
TypeName = typeName;
AssemblyName = assemblyName;
}
internal TypeLoadException(ExceptionStringID id, string typeName, string assemblyName)
: base(id, new string[] { typeName, assemblyName })
{
TypeName = typeName;
AssemblyName = assemblyName;
}
}
/// <summary>
/// The exception that is thrown when there is an attempt to access a class member that does not exist
/// or that is not declared as public.
/// </summary>
public abstract class MissingMemberException : TypeSystemException
{
protected internal MissingMemberException(ExceptionStringID id, params string[] args)
: base(id, args)
{
}
}
/// <summary>
/// The exception that is thrown when there is an attempt to access a method that does not exist.
/// </summary>
public class MissingMethodException : MissingMemberException
{
internal MissingMethodException(ExceptionStringID id, params string[] args)
: base(id, args)
{
}
}
/// <summary>
/// The exception that is thrown when there is an attempt to access a field that does not exist.
/// </summary>
public class MissingFieldException : MissingMemberException
{
internal MissingFieldException(ExceptionStringID id, params string[] args)
: base(id, args)
{
}
}
/// <summary>
/// The exception that is thrown when an attempt to access a file that does not exist on disk fails.
/// </summary>
public class FileNotFoundException : TypeSystemException
{
internal FileNotFoundException(ExceptionStringID id, string fileName)
: base(id, fileName)
{
}
}
/// <summary>
/// The exception that is thrown when a program contains invalid Microsoft intermediate language (MSIL) or metadata.
/// Generally this indicates a bug in the compiler that generated the program.
/// </summary>
public class InvalidProgramException : TypeSystemException
{
internal InvalidProgramException(ExceptionStringID id, string method)
: base(id, method)
{
}
internal InvalidProgramException(ExceptionStringID id)
: base(id)
{
}
internal InvalidProgramException()
: base(ExceptionStringID.InvalidProgramDefault)
{
}
}
public class BadImageFormatException : TypeSystemException
{
internal BadImageFormatException()
: base(ExceptionStringID.BadImageFormatGeneric)
{
}
internal BadImageFormatException(string reason)
: base(ExceptionStringID.BadImageFormatSpecific, reason)
{
}
}
public class MarshalDirectiveException : TypeSystemException
{
internal MarshalDirectiveException(ExceptionStringID id)
: base(id)
{
}
}
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Collections/tests/Generic/SortedDictionary/SortedDictionary.Generic.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using Xunit;
namespace System.Collections.Tests
{
public class SortedDictionary_Generic_Tests_string_string : SortedDictionary_Generic_Tests<string, string>
{
protected override KeyValuePair<string, string> CreateT(int seed)
{
return new KeyValuePair<string, string>(CreateTKey(seed), CreateTKey(seed + 500));
}
protected override string CreateTKey(int seed)
{
int stringLength = seed % 10 + 5;
Random rand = new Random(seed);
byte[] bytes1 = new byte[stringLength];
rand.NextBytes(bytes1);
return Convert.ToBase64String(bytes1);
}
protected override string CreateTValue(int seed)
{
return CreateTKey(seed);
}
}
public class SortedDictionary_Generic_Tests_int_int : SortedDictionary_Generic_Tests<int, int>
{
protected override bool DefaultValueAllowed { get { return true; } }
protected override KeyValuePair<int, int> CreateT(int seed)
{
Random rand = new Random(seed);
return new KeyValuePair<int, int>(rand.Next(), rand.Next());
}
protected override int CreateTKey(int seed)
{
Random rand = new Random(seed);
return rand.Next();
}
protected override int CreateTValue(int seed)
{
return CreateTKey(seed);
}
}
[OuterLoop]
public class SortedDictionary_Generic_Tests_EquatableBackwardsOrder_int : SortedDictionary_Generic_Tests<EquatableBackwardsOrder, int>
{
protected override KeyValuePair<EquatableBackwardsOrder, int> CreateT(int seed)
{
Random rand = new Random(seed);
return new KeyValuePair<EquatableBackwardsOrder, int>(new EquatableBackwardsOrder(rand.Next()), rand.Next());
}
protected override EquatableBackwardsOrder CreateTKey(int seed)
{
Random rand = new Random(seed);
return new EquatableBackwardsOrder(rand.Next());
}
protected override int CreateTValue(int seed)
{
Random rand = new Random(seed);
return rand.Next();
}
protected override IDictionary<EquatableBackwardsOrder, int> GenericIDictionaryFactory()
{
return new SortedDictionary<EquatableBackwardsOrder, int>();
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using Xunit;
namespace System.Collections.Tests
{
public class SortedDictionary_Generic_Tests_string_string : SortedDictionary_Generic_Tests<string, string>
{
protected override KeyValuePair<string, string> CreateT(int seed)
{
return new KeyValuePair<string, string>(CreateTKey(seed), CreateTKey(seed + 500));
}
protected override string CreateTKey(int seed)
{
int stringLength = seed % 10 + 5;
Random rand = new Random(seed);
byte[] bytes1 = new byte[stringLength];
rand.NextBytes(bytes1);
return Convert.ToBase64String(bytes1);
}
protected override string CreateTValue(int seed)
{
return CreateTKey(seed);
}
}
public class SortedDictionary_Generic_Tests_int_int : SortedDictionary_Generic_Tests<int, int>
{
protected override bool DefaultValueAllowed { get { return true; } }
protected override KeyValuePair<int, int> CreateT(int seed)
{
Random rand = new Random(seed);
return new KeyValuePair<int, int>(rand.Next(), rand.Next());
}
protected override int CreateTKey(int seed)
{
Random rand = new Random(seed);
return rand.Next();
}
protected override int CreateTValue(int seed)
{
return CreateTKey(seed);
}
}
[OuterLoop]
public class SortedDictionary_Generic_Tests_EquatableBackwardsOrder_int : SortedDictionary_Generic_Tests<EquatableBackwardsOrder, int>
{
protected override KeyValuePair<EquatableBackwardsOrder, int> CreateT(int seed)
{
Random rand = new Random(seed);
return new KeyValuePair<EquatableBackwardsOrder, int>(new EquatableBackwardsOrder(rand.Next()), rand.Next());
}
protected override EquatableBackwardsOrder CreateTKey(int seed)
{
Random rand = new Random(seed);
return new EquatableBackwardsOrder(rand.Next());
}
protected override int CreateTValue(int seed)
{
Random rand = new Random(seed);
return rand.Next();
}
protected override IDictionary<EquatableBackwardsOrder, int> GenericIDictionaryFactory()
{
return new SortedDictionary<EquatableBackwardsOrder, int>();
}
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/tests/JIT/Methodical/int64/unsigned/ldc_mulovf_r.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
</PropertyGroup>
<PropertyGroup>
<DebugType>None</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="ldc_mulovf.cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
</PropertyGroup>
<PropertyGroup>
<DebugType>None</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="ldc_mulovf.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd.Arm64/AddAcross.Vector128.UInt16.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void AddAcross_Vector128_UInt16()
{
var test = new SimpleUnaryOpTest__AddAcross_Vector128_UInt16();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class SimpleUnaryOpTest__AddAcross_Vector128_UInt16
{
private struct DataTable
{
private byte[] inArray1;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle outHandle;
private ulong alignment;
public DataTable(UInt16[] inArray1, UInt16[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<UInt16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<UInt16>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<UInt16, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<UInt16> _fld1;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref testStruct._fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
return testStruct;
}
public void RunStructFldScenario(SimpleUnaryOpTest__AddAcross_Vector128_UInt16 testClass)
{
var result = AdvSimd.Arm64.AddAcross(_fld1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleUnaryOpTest__AddAcross_Vector128_UInt16 testClass)
{
fixed (Vector128<UInt16>* pFld1 = &_fld1)
{
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<UInt16>>() / sizeof(UInt16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static UInt16[] _data1 = new UInt16[Op1ElementCount];
private static Vector128<UInt16> _clsVar1;
private Vector128<UInt16> _fld1;
private DataTable _dataTable;
static SimpleUnaryOpTest__AddAcross_Vector128_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
public SimpleUnaryOpTest__AddAcross_Vector128_UInt16()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
_dataTable = new DataTable(_data1, new UInt16[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.Arm64.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.Arm64.AddAcross(
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.AddAcross), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr)
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.AddAcross), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.Arm64.AddAcross(
_clsVar1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<UInt16>* pClsVar1 = &_clsVar1)
{
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(pClsVar1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr);
var result = AdvSimd.Arm64.AddAcross(op1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr));
var result = AdvSimd.Arm64.AddAcross(op1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleUnaryOpTest__AddAcross_Vector128_UInt16();
var result = AdvSimd.Arm64.AddAcross(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleUnaryOpTest__AddAcross_Vector128_UInt16();
fixed (Vector128<UInt16>* pFld1 = &test._fld1)
{
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.Arm64.AddAcross(_fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<UInt16>* pFld1 = &_fld1)
{
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.AddAcross(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(&test._fld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<UInt16> op1, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), op1);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (Helpers.AddAcross(firstOp) != result[0])
{
succeeded = false;
}
else
{
for (int i = 1; i < RetElementCount; i++)
{
if (result[i] != 0)
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd.Arm64)}.{nameof(AdvSimd.Arm64.AddAcross)}<UInt16>(Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void AddAcross_Vector128_UInt16()
{
var test = new SimpleUnaryOpTest__AddAcross_Vector128_UInt16();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class SimpleUnaryOpTest__AddAcross_Vector128_UInt16
{
private struct DataTable
{
private byte[] inArray1;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle outHandle;
private ulong alignment;
public DataTable(UInt16[] inArray1, UInt16[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<UInt16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<UInt16>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<UInt16, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<UInt16> _fld1;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref testStruct._fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
return testStruct;
}
public void RunStructFldScenario(SimpleUnaryOpTest__AddAcross_Vector128_UInt16 testClass)
{
var result = AdvSimd.Arm64.AddAcross(_fld1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleUnaryOpTest__AddAcross_Vector128_UInt16 testClass)
{
fixed (Vector128<UInt16>* pFld1 = &_fld1)
{
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<UInt16>>() / sizeof(UInt16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static UInt16[] _data1 = new UInt16[Op1ElementCount];
private static Vector128<UInt16> _clsVar1;
private Vector128<UInt16> _fld1;
private DataTable _dataTable;
static SimpleUnaryOpTest__AddAcross_Vector128_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
public SimpleUnaryOpTest__AddAcross_Vector128_UInt16()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
_dataTable = new DataTable(_data1, new UInt16[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.Arm64.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.Arm64.AddAcross(
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.AddAcross), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr)
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.AddAcross), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.Arm64.AddAcross(
_clsVar1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<UInt16>* pClsVar1 = &_clsVar1)
{
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(pClsVar1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr);
var result = AdvSimd.Arm64.AddAcross(op1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr));
var result = AdvSimd.Arm64.AddAcross(op1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleUnaryOpTest__AddAcross_Vector128_UInt16();
var result = AdvSimd.Arm64.AddAcross(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleUnaryOpTest__AddAcross_Vector128_UInt16();
fixed (Vector128<UInt16>* pFld1 = &test._fld1)
{
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.Arm64.AddAcross(_fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<UInt16>* pFld1 = &_fld1)
{
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.AddAcross(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.AddAcross(
AdvSimd.LoadVector128((UInt16*)(&test._fld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<UInt16> op1, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), op1);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (Helpers.AddAcross(firstOp) != result[0])
{
succeeded = false;
}
else
{
for (int i = 1; i < RetElementCount; i++)
{
if (result[i] != 0)
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd.Arm64)}.{nameof(AdvSimd.Arm64.AddAcross)}<UInt16>(Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Net.Http.Json/ref/System.Net.Http.Json.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<Compile Include="System.Net.Http.Json.cs" />
<Compile Include="System.Net.Http.Json.netcoreapp.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
<Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMembersAttribute.cs" />
<Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMemberTypes.cs" />
<Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="$(LibrariesProjectRoot)System.Text.Json\ref\System.Text.Json.csproj" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
<ProjectReference Include="$(LibrariesProjectRoot)System.Net.Http\ref\System.Net.Http.csproj" />
<ProjectReference Include="$(LibrariesProjectRoot)System.Net.Primitives\ref\System.Net.Primitives.csproj" />
<ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' and '$(TargetFramework)' != '$(NetCoreAppCurrent)'">
<Reference Include="System.Net.Http" />
<Reference Include="System.Net.Primitives"/>
<Reference Include="System.Runtime" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'">
<Reference Include="System.Net.Http" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<Compile Include="System.Net.Http.Json.cs" />
<Compile Include="System.Net.Http.Json.netcoreapp.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
<Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMembersAttribute.cs" />
<Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMemberTypes.cs" />
<Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="$(LibrariesProjectRoot)System.Text.Json\ref\System.Text.Json.csproj" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
<ProjectReference Include="$(LibrariesProjectRoot)System.Net.Http\ref\System.Net.Http.csproj" />
<ProjectReference Include="$(LibrariesProjectRoot)System.Net.Primitives\ref\System.Net.Primitives.csproj" />
<ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' and '$(TargetFramework)' != '$(NetCoreAppCurrent)'">
<Reference Include="System.Net.Http" />
<Reference Include="System.Net.Primitives"/>
<Reference Include="System.Runtime" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'">
<Reference Include="System.Net.Http" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Reflection.Metadata/tests/Metadata/Ecma335/PortablePdbBuilderTests.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Immutable;
using System.Reflection.Metadata.Tests;
using Xunit;
namespace System.Reflection.Metadata.Ecma335.Tests
{
public class PortablePdbBuilderTests
{
[Fact]
public void Ctor_Errors()
{
var mdBuilder = new MetadataBuilder();
Assert.Throws<ArgumentNullException>(() => new PortablePdbBuilder(null, MetadataRootBuilder.EmptyRowCounts, default(MethodDefinitionHandle)));
Assert.Throws<ArgumentNullException>(() => new PortablePdbBuilder(mdBuilder, default(ImmutableArray<int>), default(MethodDefinitionHandle)));
var rowCounts = new int[128];
rowCounts[64] = 1;
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[63] = 1;
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[(int)TableIndex.EventPtr] = 1;
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[(int)TableIndex.CustomDebugInformation] = 1;
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[(int)TableIndex.MethodDef] = -1;
Assert.Throws<ArgumentOutOfRangeException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[(int)TableIndex.GenericParamConstraint] = 0x01000000;
Assert.Throws<ArgumentOutOfRangeException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
}
[Fact]
public void Serialize_Errors()
{
var mdBuilder = new MetadataBuilder();
var pdbBuilder = new PortablePdbBuilder(mdBuilder, MetadataRootBuilder.EmptyRowCounts, default(MethodDefinitionHandle));
var builder = new BlobBuilder();
Assert.Throws<ArgumentNullException>(() => pdbBuilder.Serialize(null));
}
[Fact]
public void Headers()
{
var mdBuilder = new MetadataBuilder();
var pdbBuilder = new PortablePdbBuilder(
mdBuilder,
MetadataRootBuilder.EmptyRowCounts,
MetadataTokens.MethodDefinitionHandle(0x123456),
_ => new BlobContentId(new Guid("44332211-6655-8877-AA99-010203040506"), 0xFFEEDDCC));
var builder = new BlobBuilder();
pdbBuilder.Serialize(builder);
AssertEx.Equal(new byte[]
{
// signature:
0x42, 0x53, 0x4A, 0x42,
// major version (1)
0x01, 0x00,
// minor version (1)
0x01, 0x00,
// reserved (0)
0x00, 0x00, 0x00, 0x00,
// padded version length:
0x0C, 0x00, 0x00, 0x00,
// padded version:
(byte)'P', (byte)'D', (byte)'B', (byte)' ', (byte)'v', (byte)'1', (byte)'.', (byte)'0', 0x00, 0x00, 0x00, 0x00,
// flags (0):
0x00, 0x00,
// stream count:
0x06, 0x00,
// stream headers (offset, size, padded name)
0x7C, 0x00, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00,
(byte)'#', (byte)'P', (byte)'d', (byte)'b', 0x00, 0x00, 0x00, 0x00,
0x9C, 0x00, 0x00, 0x00,
0x1C, 0x00, 0x00, 0x00,
(byte)'#', (byte)'~', 0x00, 0x00,
0xB8, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
(byte)'#', (byte)'S', (byte)'t', (byte)'r', (byte)'i', (byte)'n', (byte)'g', (byte)'s', 0x00, 0x00, 0x00, 0x00,
0xBC, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
(byte)'#', (byte)'U', (byte)'S', 0x00,
0xC0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
(byte)'#', (byte)'G', (byte)'U', (byte)'I', (byte)'D', 0x00, 0x00, 0x00,
0xC0, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
(byte)'#', (byte)'B', (byte)'l', (byte)'o', (byte)'b', 0x00, 0x00, 0x00,
// --------
// #Pdb
// --------
// PDB ID
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0xAA, 0x99, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0xCC, 0xDD, 0xEE, 0xFF,
// EntryPoint
0x56, 0x34, 0x12, 0x06,
// ReferencedTypeSystemTables
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// TypeSystemTableRows (empty)
// --------
// #~
// --------
// Reserved (0)
0x00, 0x00, 0x00, 0x00,
// Major Version (2)
0x02,
// Minor Version (0)
0x00,
// Heap Sizes
0x00,
// Reserved (1)
0x01,
// Present tables
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Sorted tables
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Rows (empty)
// Tables (empty)
// Padding and alignment
0x00, 0x00, 0x00, 0x00,
// --------
// #Strings
// --------
0x00, 0x00, 0x00, 0x00,
// --------
// #US
// --------
0x00, 0x00, 0x00, 0x00,
// --------
// #GUID
// --------
// --------
// #Blob
// --------
0x00, 0x00, 0x00, 0x00,
}, builder.ToArray());
}
[Fact]
public void PdbStream_TypeSystemRowCounts()
{
var rowCounts = new int[MetadataTokens.TableCount];
rowCounts[(int)TableIndex.MethodDef] = 0xFFFFFF;
rowCounts[(int)TableIndex.TypeDef] = 0x123456;
var mdBuilder = new MetadataBuilder();
var pdbBuilder = new PortablePdbBuilder(
mdBuilder,
ImmutableArray.Create(rowCounts),
MetadataTokens.MethodDefinitionHandle(0x123456),
_ => new BlobContentId(new Guid("44332211-6655-8877-AA99-010203040506"), 0xFFEEDDCC));
var builder = new BlobBuilder();
pdbBuilder.Serialize(builder);
AssertEx.Equal(new byte[]
{
// PDB ID
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0xAA, 0x99, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0xCC, 0xDD, 0xEE, 0xFF,
// EntryPoint
0x56, 0x34, 0x12, 0x06,
// ReferencedTypeSystemTables
0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// TypeSystemTableRows
0x56, 0x34, 0x12, 0x00,
0xFF, 0xFF, 0xFF, 0x00
}, builder.Slice(124, -40));
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Immutable;
using System.Reflection.Metadata.Tests;
using Xunit;
namespace System.Reflection.Metadata.Ecma335.Tests
{
public class PortablePdbBuilderTests
{
[Fact]
public void Ctor_Errors()
{
var mdBuilder = new MetadataBuilder();
Assert.Throws<ArgumentNullException>(() => new PortablePdbBuilder(null, MetadataRootBuilder.EmptyRowCounts, default(MethodDefinitionHandle)));
Assert.Throws<ArgumentNullException>(() => new PortablePdbBuilder(mdBuilder, default(ImmutableArray<int>), default(MethodDefinitionHandle)));
var rowCounts = new int[128];
rowCounts[64] = 1;
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[63] = 1;
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[(int)TableIndex.EventPtr] = 1;
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[(int)TableIndex.CustomDebugInformation] = 1;
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[(int)TableIndex.MethodDef] = -1;
Assert.Throws<ArgumentOutOfRangeException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[(int)TableIndex.GenericParamConstraint] = 0x01000000;
Assert.Throws<ArgumentOutOfRangeException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
}
[Fact]
public void Serialize_Errors()
{
var mdBuilder = new MetadataBuilder();
var pdbBuilder = new PortablePdbBuilder(mdBuilder, MetadataRootBuilder.EmptyRowCounts, default(MethodDefinitionHandle));
var builder = new BlobBuilder();
Assert.Throws<ArgumentNullException>(() => pdbBuilder.Serialize(null));
}
[Fact]
public void Headers()
{
var mdBuilder = new MetadataBuilder();
var pdbBuilder = new PortablePdbBuilder(
mdBuilder,
MetadataRootBuilder.EmptyRowCounts,
MetadataTokens.MethodDefinitionHandle(0x123456),
_ => new BlobContentId(new Guid("44332211-6655-8877-AA99-010203040506"), 0xFFEEDDCC));
var builder = new BlobBuilder();
pdbBuilder.Serialize(builder);
AssertEx.Equal(new byte[]
{
// signature:
0x42, 0x53, 0x4A, 0x42,
// major version (1)
0x01, 0x00,
// minor version (1)
0x01, 0x00,
// reserved (0)
0x00, 0x00, 0x00, 0x00,
// padded version length:
0x0C, 0x00, 0x00, 0x00,
// padded version:
(byte)'P', (byte)'D', (byte)'B', (byte)' ', (byte)'v', (byte)'1', (byte)'.', (byte)'0', 0x00, 0x00, 0x00, 0x00,
// flags (0):
0x00, 0x00,
// stream count:
0x06, 0x00,
// stream headers (offset, size, padded name)
0x7C, 0x00, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00,
(byte)'#', (byte)'P', (byte)'d', (byte)'b', 0x00, 0x00, 0x00, 0x00,
0x9C, 0x00, 0x00, 0x00,
0x1C, 0x00, 0x00, 0x00,
(byte)'#', (byte)'~', 0x00, 0x00,
0xB8, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
(byte)'#', (byte)'S', (byte)'t', (byte)'r', (byte)'i', (byte)'n', (byte)'g', (byte)'s', 0x00, 0x00, 0x00, 0x00,
0xBC, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
(byte)'#', (byte)'U', (byte)'S', 0x00,
0xC0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
(byte)'#', (byte)'G', (byte)'U', (byte)'I', (byte)'D', 0x00, 0x00, 0x00,
0xC0, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
(byte)'#', (byte)'B', (byte)'l', (byte)'o', (byte)'b', 0x00, 0x00, 0x00,
// --------
// #Pdb
// --------
// PDB ID
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0xAA, 0x99, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0xCC, 0xDD, 0xEE, 0xFF,
// EntryPoint
0x56, 0x34, 0x12, 0x06,
// ReferencedTypeSystemTables
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// TypeSystemTableRows (empty)
// --------
// #~
// --------
// Reserved (0)
0x00, 0x00, 0x00, 0x00,
// Major Version (2)
0x02,
// Minor Version (0)
0x00,
// Heap Sizes
0x00,
// Reserved (1)
0x01,
// Present tables
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Sorted tables
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Rows (empty)
// Tables (empty)
// Padding and alignment
0x00, 0x00, 0x00, 0x00,
// --------
// #Strings
// --------
0x00, 0x00, 0x00, 0x00,
// --------
// #US
// --------
0x00, 0x00, 0x00, 0x00,
// --------
// #GUID
// --------
// --------
// #Blob
// --------
0x00, 0x00, 0x00, 0x00,
}, builder.ToArray());
}
[Fact]
public void PdbStream_TypeSystemRowCounts()
{
var rowCounts = new int[MetadataTokens.TableCount];
rowCounts[(int)TableIndex.MethodDef] = 0xFFFFFF;
rowCounts[(int)TableIndex.TypeDef] = 0x123456;
var mdBuilder = new MetadataBuilder();
var pdbBuilder = new PortablePdbBuilder(
mdBuilder,
ImmutableArray.Create(rowCounts),
MetadataTokens.MethodDefinitionHandle(0x123456),
_ => new BlobContentId(new Guid("44332211-6655-8877-AA99-010203040506"), 0xFFEEDDCC));
var builder = new BlobBuilder();
pdbBuilder.Serialize(builder);
AssertEx.Equal(new byte[]
{
// PDB ID
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0xAA, 0x99, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0xCC, 0xDD, 0xEE, 0xFF,
// EntryPoint
0x56, 0x34, 0x12, 0x06,
// ReferencedTypeSystemTables
0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// TypeSystemTableRows
0x56, 0x34, 0x12, 0x00,
0xFF, 0xFF, 0xFF, 0x00
}, builder.Slice(124, -40));
}
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Private.Xml/src/System/Xml/Xsl/Xslt/XPathPatternParser.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics;
using System.Xml;
using System.Xml.Xsl.Qil;
using System.Xml.Xsl.XPath;
namespace System.Xml.Xsl.Xslt
{
using XPathParser = XPathParser<QilNode>;
using XPathNodeType = System.Xml.XPath.XPathNodeType;
internal sealed class XPathPatternParser
{
public interface IPatternBuilder : IXPathBuilder<QilNode>
{
IXPathBuilder<QilNode> GetPredicateBuilder(QilNode context);
}
private XPathScanner? _scanner;
private IPatternBuilder? _ptrnBuilder;
private readonly XPathParser _predicateParser = new XPathParser();
public QilNode Parse(XPathScanner scanner, IPatternBuilder ptrnBuilder)
{
Debug.Assert(_scanner == null && _ptrnBuilder == null);
Debug.Assert(scanner != null && ptrnBuilder != null);
QilNode? result = null;
ptrnBuilder.StartBuild();
try
{
_scanner = scanner;
_ptrnBuilder = ptrnBuilder;
result = this.ParsePattern();
_scanner.CheckToken(LexKind.Eof);
}
finally
{
result = ptrnBuilder.EndBuild(result);
#if DEBUG
_ptrnBuilder = null;
_scanner = null;
#endif
}
return result!;
}
/*
* Pattern ::= LocationPathPattern ('|' LocationPathPattern)*
*/
private QilNode ParsePattern()
{
QilNode opnd = ParseLocationPathPattern();
while (_scanner!.Kind == LexKind.Union)
{
_scanner.NextLex();
opnd = _ptrnBuilder!.Operator(XPathOperator.Union, opnd, ParseLocationPathPattern());
}
return opnd;
}
/*
* LocationPathPattern ::= '/' RelativePathPattern? | '//'? RelativePathPattern | IdKeyPattern (('/' | '//') RelativePathPattern)?
*/
private QilNode ParseLocationPathPattern()
{
QilNode opnd;
switch (_scanner!.Kind)
{
case LexKind.Slash:
_scanner.NextLex();
opnd = _ptrnBuilder!.Axis(XPathAxis.Root, XPathNodeType.All, null, null);
if (XPathParser.IsStep(_scanner.Kind))
{
opnd = _ptrnBuilder.JoinStep(opnd, ParseRelativePathPattern());
}
return opnd;
case LexKind.SlashSlash:
_scanner.NextLex();
return _ptrnBuilder!.JoinStep(
_ptrnBuilder.Axis(XPathAxis.Root, XPathNodeType.All, null, null),
_ptrnBuilder.JoinStep(
_ptrnBuilder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null),
ParseRelativePathPattern()
)
);
case LexKind.Name:
if (_scanner.CanBeFunction && _scanner.Prefix.Length == 0 && (_scanner.Name == "id" || _scanner.Name == "key"))
{
opnd = ParseIdKeyPattern();
switch (_scanner.Kind)
{
case LexKind.Slash:
_scanner.NextLex();
opnd = _ptrnBuilder!.JoinStep(opnd, ParseRelativePathPattern());
break;
case LexKind.SlashSlash:
_scanner.NextLex();
opnd = _ptrnBuilder!.JoinStep(opnd,
_ptrnBuilder.JoinStep(
_ptrnBuilder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null),
ParseRelativePathPattern()
)
);
break;
}
return opnd;
}
break;
}
opnd = ParseRelativePathPattern();
return opnd;
}
/*
* IdKeyPattern ::= 'id' '(' Literal ')' | 'key' '(' Literal ',' Literal ')'
*/
private QilNode ParseIdKeyPattern()
{
Debug.Assert(_scanner!.CanBeFunction);
Debug.Assert(_scanner.Prefix.Length == 0);
Debug.Assert(_scanner.Name == "id" || _scanner.Name == "key");
List<QilNode> args = new List<QilNode>(2);
if (_scanner.Name == "id")
{
_scanner.NextLex();
_scanner.PassToken(LexKind.LParens);
_scanner.CheckToken(LexKind.String);
args.Add(_ptrnBuilder!.String(_scanner.StringValue));
_scanner.NextLex();
_scanner.PassToken(LexKind.RParens);
return _ptrnBuilder.Function("", "id", args);
}
else
{
_scanner.NextLex();
_scanner.PassToken(LexKind.LParens);
_scanner.CheckToken(LexKind.String);
args.Add(_ptrnBuilder!.String(_scanner.StringValue));
_scanner.NextLex();
_scanner.PassToken(LexKind.Comma);
_scanner.CheckToken(LexKind.String);
args.Add(_ptrnBuilder.String(_scanner.StringValue));
_scanner.NextLex();
_scanner.PassToken(LexKind.RParens);
return _ptrnBuilder.Function("", "key", args);
}
}
/*
* RelativePathPattern ::= StepPattern (('/' | '//') StepPattern)*
*/
//Max depth to avoid StackOverflow
private const int MaxParseRelativePathDepth = 1024;
private int _parseRelativePath;
private QilNode ParseRelativePathPattern()
{
if (++_parseRelativePath > MaxParseRelativePathDepth)
{
if (LocalAppContextSwitches.LimitXPathComplexity)
{
throw _scanner!.CreateException(SR.Xslt_InputTooComplex);
}
}
QilNode opnd = ParseStepPattern();
if (_scanner!.Kind == LexKind.Slash)
{
_scanner.NextLex();
opnd = _ptrnBuilder!.JoinStep(opnd, ParseRelativePathPattern());
}
else if (_scanner.Kind == LexKind.SlashSlash)
{
_scanner.NextLex();
opnd = _ptrnBuilder!.JoinStep(opnd,
_ptrnBuilder.JoinStep(
_ptrnBuilder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null),
ParseRelativePathPattern()
)
);
}
--_parseRelativePath;
return opnd;
}
/*
* StepPattern ::= ChildOrAttributeAxisSpecifier NodeTest Predicate*
* ChildOrAttributeAxisSpecifier ::= @ ? | ('child' | 'attribute') '::'
*/
private QilNode ParseStepPattern()
{
QilNode opnd;
XPathAxis axis;
switch (_scanner!.Kind)
{
case LexKind.Dot:
case LexKind.DotDot:
throw _scanner.CreateException(SR.XPath_InvalidAxisInPattern);
case LexKind.At:
axis = XPathAxis.Attribute;
_scanner.NextLex();
break;
case LexKind.Axis:
axis = _scanner.Axis;
if (axis != XPathAxis.Child && axis != XPathAxis.Attribute)
{
throw _scanner.CreateException(SR.XPath_InvalidAxisInPattern);
}
_scanner.NextLex(); // Skip '::'
_scanner.NextLex();
break;
case LexKind.Name:
case LexKind.Star:
// NodeTest must start with Name or '*'
axis = XPathAxis.Child;
break;
default:
throw _scanner.CreateException(SR.XPath_UnexpectedToken, _scanner.RawValue);
}
XPathNodeType nodeType;
string? nodePrefix, nodeName;
XPathParser.InternalParseNodeTest(_scanner, axis, out nodeType, out nodePrefix, out nodeName);
opnd = _ptrnBuilder!.Axis(axis, nodeType, nodePrefix, nodeName);
XPathPatternBuilder? xpathPatternBuilder = _ptrnBuilder as XPathPatternBuilder;
if (xpathPatternBuilder != null)
{
//for XPathPatternBuilder, get all predicates and then build them
List<QilNode> predicates = new List<QilNode>();
while (_scanner.Kind == LexKind.LBracket)
{
predicates.Add(ParsePredicate(opnd));
}
if (predicates.Count > 0)
opnd = xpathPatternBuilder.BuildPredicates(opnd, predicates);
}
else
{
while (_scanner.Kind == LexKind.LBracket)
{
opnd = _ptrnBuilder.Predicate(opnd, ParsePredicate(opnd), /*reverseStep:*/false);
}
}
return opnd;
}
/*
* Predicate ::= '[' Expr ']'
*/
private QilNode ParsePredicate(QilNode context)
{
Debug.Assert(_scanner!.Kind == LexKind.LBracket);
_scanner.NextLex();
QilNode result = _predicateParser.Parse(_scanner, _ptrnBuilder!.GetPredicateBuilder(context), LexKind.RBracket);
Debug.Assert(_scanner.Kind == LexKind.RBracket);
_scanner.NextLex();
return result;
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics;
using System.Xml;
using System.Xml.Xsl.Qil;
using System.Xml.Xsl.XPath;
namespace System.Xml.Xsl.Xslt
{
using XPathParser = XPathParser<QilNode>;
using XPathNodeType = System.Xml.XPath.XPathNodeType;
internal sealed class XPathPatternParser
{
public interface IPatternBuilder : IXPathBuilder<QilNode>
{
IXPathBuilder<QilNode> GetPredicateBuilder(QilNode context);
}
private XPathScanner? _scanner;
private IPatternBuilder? _ptrnBuilder;
private readonly XPathParser _predicateParser = new XPathParser();
public QilNode Parse(XPathScanner scanner, IPatternBuilder ptrnBuilder)
{
Debug.Assert(_scanner == null && _ptrnBuilder == null);
Debug.Assert(scanner != null && ptrnBuilder != null);
QilNode? result = null;
ptrnBuilder.StartBuild();
try
{
_scanner = scanner;
_ptrnBuilder = ptrnBuilder;
result = this.ParsePattern();
_scanner.CheckToken(LexKind.Eof);
}
finally
{
result = ptrnBuilder.EndBuild(result);
#if DEBUG
_ptrnBuilder = null;
_scanner = null;
#endif
}
return result!;
}
/*
* Pattern ::= LocationPathPattern ('|' LocationPathPattern)*
*/
private QilNode ParsePattern()
{
QilNode opnd = ParseLocationPathPattern();
while (_scanner!.Kind == LexKind.Union)
{
_scanner.NextLex();
opnd = _ptrnBuilder!.Operator(XPathOperator.Union, opnd, ParseLocationPathPattern());
}
return opnd;
}
/*
* LocationPathPattern ::= '/' RelativePathPattern? | '//'? RelativePathPattern | IdKeyPattern (('/' | '//') RelativePathPattern)?
*/
private QilNode ParseLocationPathPattern()
{
QilNode opnd;
switch (_scanner!.Kind)
{
case LexKind.Slash:
_scanner.NextLex();
opnd = _ptrnBuilder!.Axis(XPathAxis.Root, XPathNodeType.All, null, null);
if (XPathParser.IsStep(_scanner.Kind))
{
opnd = _ptrnBuilder.JoinStep(opnd, ParseRelativePathPattern());
}
return opnd;
case LexKind.SlashSlash:
_scanner.NextLex();
return _ptrnBuilder!.JoinStep(
_ptrnBuilder.Axis(XPathAxis.Root, XPathNodeType.All, null, null),
_ptrnBuilder.JoinStep(
_ptrnBuilder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null),
ParseRelativePathPattern()
)
);
case LexKind.Name:
if (_scanner.CanBeFunction && _scanner.Prefix.Length == 0 && (_scanner.Name == "id" || _scanner.Name == "key"))
{
opnd = ParseIdKeyPattern();
switch (_scanner.Kind)
{
case LexKind.Slash:
_scanner.NextLex();
opnd = _ptrnBuilder!.JoinStep(opnd, ParseRelativePathPattern());
break;
case LexKind.SlashSlash:
_scanner.NextLex();
opnd = _ptrnBuilder!.JoinStep(opnd,
_ptrnBuilder.JoinStep(
_ptrnBuilder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null),
ParseRelativePathPattern()
)
);
break;
}
return opnd;
}
break;
}
opnd = ParseRelativePathPattern();
return opnd;
}
/*
* IdKeyPattern ::= 'id' '(' Literal ')' | 'key' '(' Literal ',' Literal ')'
*/
private QilNode ParseIdKeyPattern()
{
Debug.Assert(_scanner!.CanBeFunction);
Debug.Assert(_scanner.Prefix.Length == 0);
Debug.Assert(_scanner.Name == "id" || _scanner.Name == "key");
List<QilNode> args = new List<QilNode>(2);
if (_scanner.Name == "id")
{
_scanner.NextLex();
_scanner.PassToken(LexKind.LParens);
_scanner.CheckToken(LexKind.String);
args.Add(_ptrnBuilder!.String(_scanner.StringValue));
_scanner.NextLex();
_scanner.PassToken(LexKind.RParens);
return _ptrnBuilder.Function("", "id", args);
}
else
{
_scanner.NextLex();
_scanner.PassToken(LexKind.LParens);
_scanner.CheckToken(LexKind.String);
args.Add(_ptrnBuilder!.String(_scanner.StringValue));
_scanner.NextLex();
_scanner.PassToken(LexKind.Comma);
_scanner.CheckToken(LexKind.String);
args.Add(_ptrnBuilder.String(_scanner.StringValue));
_scanner.NextLex();
_scanner.PassToken(LexKind.RParens);
return _ptrnBuilder.Function("", "key", args);
}
}
/*
* RelativePathPattern ::= StepPattern (('/' | '//') StepPattern)*
*/
//Max depth to avoid StackOverflow
private const int MaxParseRelativePathDepth = 1024;
private int _parseRelativePath;
private QilNode ParseRelativePathPattern()
{
if (++_parseRelativePath > MaxParseRelativePathDepth)
{
if (LocalAppContextSwitches.LimitXPathComplexity)
{
throw _scanner!.CreateException(SR.Xslt_InputTooComplex);
}
}
QilNode opnd = ParseStepPattern();
if (_scanner!.Kind == LexKind.Slash)
{
_scanner.NextLex();
opnd = _ptrnBuilder!.JoinStep(opnd, ParseRelativePathPattern());
}
else if (_scanner.Kind == LexKind.SlashSlash)
{
_scanner.NextLex();
opnd = _ptrnBuilder!.JoinStep(opnd,
_ptrnBuilder.JoinStep(
_ptrnBuilder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null),
ParseRelativePathPattern()
)
);
}
--_parseRelativePath;
return opnd;
}
/*
* StepPattern ::= ChildOrAttributeAxisSpecifier NodeTest Predicate*
* ChildOrAttributeAxisSpecifier ::= @ ? | ('child' | 'attribute') '::'
*/
private QilNode ParseStepPattern()
{
QilNode opnd;
XPathAxis axis;
switch (_scanner!.Kind)
{
case LexKind.Dot:
case LexKind.DotDot:
throw _scanner.CreateException(SR.XPath_InvalidAxisInPattern);
case LexKind.At:
axis = XPathAxis.Attribute;
_scanner.NextLex();
break;
case LexKind.Axis:
axis = _scanner.Axis;
if (axis != XPathAxis.Child && axis != XPathAxis.Attribute)
{
throw _scanner.CreateException(SR.XPath_InvalidAxisInPattern);
}
_scanner.NextLex(); // Skip '::'
_scanner.NextLex();
break;
case LexKind.Name:
case LexKind.Star:
// NodeTest must start with Name or '*'
axis = XPathAxis.Child;
break;
default:
throw _scanner.CreateException(SR.XPath_UnexpectedToken, _scanner.RawValue);
}
XPathNodeType nodeType;
string? nodePrefix, nodeName;
XPathParser.InternalParseNodeTest(_scanner, axis, out nodeType, out nodePrefix, out nodeName);
opnd = _ptrnBuilder!.Axis(axis, nodeType, nodePrefix, nodeName);
XPathPatternBuilder? xpathPatternBuilder = _ptrnBuilder as XPathPatternBuilder;
if (xpathPatternBuilder != null)
{
//for XPathPatternBuilder, get all predicates and then build them
List<QilNode> predicates = new List<QilNode>();
while (_scanner.Kind == LexKind.LBracket)
{
predicates.Add(ParsePredicate(opnd));
}
if (predicates.Count > 0)
opnd = xpathPatternBuilder.BuildPredicates(opnd, predicates);
}
else
{
while (_scanner.Kind == LexKind.LBracket)
{
opnd = _ptrnBuilder.Predicate(opnd, ParsePredicate(opnd), /*reverseStep:*/false);
}
}
return opnd;
}
/*
* Predicate ::= '[' Expr ']'
*/
private QilNode ParsePredicate(QilNode context)
{
Debug.Assert(_scanner!.Kind == LexKind.LBracket);
_scanner.NextLex();
QilNode result = _predicateParser.Parse(_scanner, _ptrnBuilder!.GetPredicateBuilder(context), LexKind.RBracket);
Debug.Assert(_scanner.Kind == LexKind.RBracket);
_scanner.NextLex();
return result;
}
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.ServiceProcess.ServiceController/src/System/ServiceProcess/SessionChangeDescription.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Diagnostics.CodeAnalysis;
namespace System.ServiceProcess
{
public readonly struct SessionChangeDescription
#if NETCOREAPP
: IEquatable<SessionChangeDescription>
#endif
{
internal SessionChangeDescription(SessionChangeReason reason, int id)
{
Reason = reason;
SessionId = id;
}
public SessionChangeReason Reason { get; }
public int SessionId { get; }
public override int GetHashCode() =>
(int)Reason ^ SessionId;
public override bool Equals([NotNullWhen(true)] object? obj) =>
obj is SessionChangeDescription other && Equals(other);
public bool Equals(SessionChangeDescription changeDescription) =>
(Reason == changeDescription.Reason) &&
(SessionId == changeDescription.SessionId);
public static bool operator ==(SessionChangeDescription a, SessionChangeDescription b) =>
a.Equals(b);
public static bool operator !=(SessionChangeDescription a, SessionChangeDescription b) =>
!a.Equals(b);
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Diagnostics.CodeAnalysis;
namespace System.ServiceProcess
{
public readonly struct SessionChangeDescription
#if NETCOREAPP
: IEquatable<SessionChangeDescription>
#endif
{
internal SessionChangeDescription(SessionChangeReason reason, int id)
{
Reason = reason;
SessionId = id;
}
public SessionChangeReason Reason { get; }
public int SessionId { get; }
public override int GetHashCode() =>
(int)Reason ^ SessionId;
public override bool Equals([NotNullWhen(true)] object? obj) =>
obj is SessionChangeDescription other && Equals(other);
public bool Equals(SessionChangeDescription changeDescription) =>
(Reason == changeDescription.Reason) &&
(SessionId == changeDescription.SessionId);
public static bool operator ==(SessionChangeDescription a, SessionChangeDescription b) =>
a.Equals(b);
public static bool operator !=(SessionChangeDescription a, SessionChangeDescription b) =>
!a.Equals(b);
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/tests/JIT/HardwareIntrinsics/General/Vector64/GreaterThanAny.Byte.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
namespace JIT.HardwareIntrinsics.General
{
public static partial class Program
{
private static void GreaterThanAnyByte()
{
var test = new VectorBooleanBinaryOpTest__GreaterThanAnyByte();
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
// Validates passing a static member works
test.RunClsVarScenario();
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
// Validates passing an instance member of a class works
test.RunClassFldScenario();
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class VectorBooleanBinaryOpTest__GreaterThanAnyByte
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private GCHandle inHandle1;
private GCHandle inHandle2;
private ulong alignment;
public DataTable(Byte[] inArray1, Byte[] inArray2, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Byte>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<Byte>();
if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Byte, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<Byte, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<Byte> _fld1;
public Vector64<Byte> _fld2;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref testStruct._fld1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref testStruct._fld2), ref Unsafe.As<Byte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
return testStruct;
}
public void RunStructFldScenario(VectorBooleanBinaryOpTest__GreaterThanAnyByte testClass)
{
var result = Vector64.GreaterThanAny(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private static readonly int LargestVectorSize = 8;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<Byte>>() / sizeof(Byte);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector64<Byte>>() / sizeof(Byte);
private static Byte[] _data1 = new Byte[Op1ElementCount];
private static Byte[] _data2 = new Byte[Op2ElementCount];
private static Vector64<Byte> _clsVar1;
private static Vector64<Byte> _clsVar2;
private Vector64<Byte> _fld1;
private Vector64<Byte> _fld2;
private DataTable _dataTable;
static VectorBooleanBinaryOpTest__GreaterThanAnyByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _clsVar1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _clsVar2), ref Unsafe.As<Byte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
}
public VectorBooleanBinaryOpTest__GreaterThanAnyByte()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _fld1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _fld2), ref Unsafe.As<Byte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetByte(); }
_dataTable = new DataTable(_data1, _data2, LargestVectorSize);
}
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = Vector64.GreaterThanAny(
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray2Ptr)
);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, result);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var method = typeof(Vector64).GetMethod(nameof(Vector64.GreaterThanAny), new Type[] {
typeof(Vector64<Byte>),
typeof(Vector64<Byte>)
});
if (method is null)
{
method = typeof(Vector64).GetMethod(nameof(Vector64.GreaterThanAny), 1, new Type[] {
typeof(Vector64<>).MakeGenericType(Type.MakeGenericMethodParameter(0)),
typeof(Vector64<>).MakeGenericType(Type.MakeGenericMethodParameter(0))
});
}
if (method.IsGenericMethodDefinition)
{
method = method.MakeGenericMethod(typeof(Byte));
}
var result = method.Invoke(null, new object[] {
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray2Ptr)
});
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = Vector64.GreaterThanAny(
_clsVar1,
_clsVar2
);
ValidateResult(_clsVar1, _clsVar2, result);
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<Byte>>(_dataTable.inArray2Ptr);
var result = Vector64.GreaterThanAny(op1, op2);
ValidateResult(op1, op2, result);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new VectorBooleanBinaryOpTest__GreaterThanAnyByte();
var result = Vector64.GreaterThanAny(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = Vector64.GreaterThanAny(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = Vector64.GreaterThanAny(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
private void ValidateResult(Vector64<Byte> op1, Vector64<Byte> op2, bool result, [CallerMemberName] string method = "")
{
Byte[] inArray1 = new Byte[Op1ElementCount];
Byte[] inArray2 = new Byte[Op2ElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<Byte, byte>(ref inArray2[0]), op2);
ValidateResult(inArray1, inArray2, result, method);
}
private void ValidateResult(void* op1, void* op2, bool result, [CallerMemberName] string method = "")
{
Byte[] inArray1 = new Byte[Op1ElementCount];
Byte[] inArray2 = new Byte[Op2ElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<Vector64<Byte>>());
ValidateResult(inArray1, inArray2, result, method);
}
private void ValidateResult(Byte[] left, Byte[] right, bool result, [CallerMemberName] string method = "")
{
bool succeeded = true;
var expectedResult = false;
for (var i = 0; i < Op1ElementCount; i++)
{
expectedResult |= (left[i] > right[i]);
}
succeeded = (expectedResult == result);
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(Vector64)}.{nameof(Vector64.GreaterThanAny)}<Byte>(Vector64<Byte>, Vector64<Byte>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({result})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
namespace JIT.HardwareIntrinsics.General
{
public static partial class Program
{
private static void GreaterThanAnyByte()
{
var test = new VectorBooleanBinaryOpTest__GreaterThanAnyByte();
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
// Validates passing a static member works
test.RunClsVarScenario();
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
// Validates passing an instance member of a class works
test.RunClassFldScenario();
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class VectorBooleanBinaryOpTest__GreaterThanAnyByte
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private GCHandle inHandle1;
private GCHandle inHandle2;
private ulong alignment;
public DataTable(Byte[] inArray1, Byte[] inArray2, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Byte>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<Byte>();
if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Byte, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<Byte, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<Byte> _fld1;
public Vector64<Byte> _fld2;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref testStruct._fld1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref testStruct._fld2), ref Unsafe.As<Byte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
return testStruct;
}
public void RunStructFldScenario(VectorBooleanBinaryOpTest__GreaterThanAnyByte testClass)
{
var result = Vector64.GreaterThanAny(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private static readonly int LargestVectorSize = 8;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<Byte>>() / sizeof(Byte);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector64<Byte>>() / sizeof(Byte);
private static Byte[] _data1 = new Byte[Op1ElementCount];
private static Byte[] _data2 = new Byte[Op2ElementCount];
private static Vector64<Byte> _clsVar1;
private static Vector64<Byte> _clsVar2;
private Vector64<Byte> _fld1;
private Vector64<Byte> _fld2;
private DataTable _dataTable;
static VectorBooleanBinaryOpTest__GreaterThanAnyByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _clsVar1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _clsVar2), ref Unsafe.As<Byte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
}
public VectorBooleanBinaryOpTest__GreaterThanAnyByte()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _fld1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _fld2), ref Unsafe.As<Byte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetByte(); }
_dataTable = new DataTable(_data1, _data2, LargestVectorSize);
}
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = Vector64.GreaterThanAny(
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray2Ptr)
);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, result);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var method = typeof(Vector64).GetMethod(nameof(Vector64.GreaterThanAny), new Type[] {
typeof(Vector64<Byte>),
typeof(Vector64<Byte>)
});
if (method is null)
{
method = typeof(Vector64).GetMethod(nameof(Vector64.GreaterThanAny), 1, new Type[] {
typeof(Vector64<>).MakeGenericType(Type.MakeGenericMethodParameter(0)),
typeof(Vector64<>).MakeGenericType(Type.MakeGenericMethodParameter(0))
});
}
if (method.IsGenericMethodDefinition)
{
method = method.MakeGenericMethod(typeof(Byte));
}
var result = method.Invoke(null, new object[] {
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray2Ptr)
});
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = Vector64.GreaterThanAny(
_clsVar1,
_clsVar2
);
ValidateResult(_clsVar1, _clsVar2, result);
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<Byte>>(_dataTable.inArray2Ptr);
var result = Vector64.GreaterThanAny(op1, op2);
ValidateResult(op1, op2, result);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new VectorBooleanBinaryOpTest__GreaterThanAnyByte();
var result = Vector64.GreaterThanAny(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = Vector64.GreaterThanAny(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = Vector64.GreaterThanAny(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
private void ValidateResult(Vector64<Byte> op1, Vector64<Byte> op2, bool result, [CallerMemberName] string method = "")
{
Byte[] inArray1 = new Byte[Op1ElementCount];
Byte[] inArray2 = new Byte[Op2ElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<Byte, byte>(ref inArray2[0]), op2);
ValidateResult(inArray1, inArray2, result, method);
}
private void ValidateResult(void* op1, void* op2, bool result, [CallerMemberName] string method = "")
{
Byte[] inArray1 = new Byte[Op1ElementCount];
Byte[] inArray2 = new Byte[Op2ElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<Vector64<Byte>>());
ValidateResult(inArray1, inArray2, result, method);
}
private void ValidateResult(Byte[] left, Byte[] right, bool result, [CallerMemberName] string method = "")
{
bool succeeded = true;
var expectedResult = false;
for (var i = 0; i < Op1ElementCount; i++)
{
expectedResult |= (left[i] > right[i]);
}
succeeded = (expectedResult == result);
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(Vector64)}.{nameof(Vector64.GreaterThanAny)}<Byte>(Vector64<Byte>, Vector64<Byte>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({result})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/Common/src/Interop/Unix/System.Native/Interop.GetControlCharacters.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.InteropServices;
internal static partial class Interop
{
internal static partial class Sys
{
[LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetControlCharacters")]
internal static partial void GetControlCharacters(
ControlCharacterNames[] controlCharacterNames, byte[] controlCharacterValues, int controlCharacterLength,
out byte posixDisableValue);
internal enum ControlCharacterNames : int
{
VINTR = 0,
VQUIT = 1,
VERASE = 2,
VKILL = 3,
VEOF = 4,
VTIME = 5,
VMIN = 6,
VSWTC = 7,
VSTART = 8,
VSTOP = 9,
VSUSP = 10,
VEOL = 11,
VREPRINT = 12,
VDISCARD = 13,
VWERASE = 14,
VLNEXT = 15,
VEOL2 = 16
};
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.InteropServices;
internal static partial class Interop
{
internal static partial class Sys
{
[LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetControlCharacters")]
internal static partial void GetControlCharacters(
ControlCharacterNames[] controlCharacterNames, byte[] controlCharacterValues, int controlCharacterLength,
out byte posixDisableValue);
internal enum ControlCharacterNames : int
{
VINTR = 0,
VQUIT = 1,
VERASE = 2,
VKILL = 3,
VEOF = 4,
VTIME = 5,
VMIN = 6,
VSWTC = 7,
VSTART = 8,
VSTOP = 9,
VSUSP = 10,
VEOL = 11,
VREPRINT = 12,
VDISCARD = 13,
VWERASE = 14,
VLNEXT = 15,
VEOL2 = 16
};
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/tests/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.SByte.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;
namespace JIT.HardwareIntrinsics.X86
{
public static partial class Program
{
private static void CompareEqualSByte()
{
var test = new SimpleBinaryOpTest__CompareEqualSByte();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (Sse2.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
// Validates basic functionality works, using LoadAligned
test.RunBasicScenario_LoadAligned();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (Sse2.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
// Validates calling via reflection works, using LoadAligned
test.RunReflectionScenario_LoadAligned();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (Sse2.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (Sse2.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
// Validates passing a local works, using LoadAligned
test.RunLclVarScenario_LoadAligned();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (Sse2.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (Sse2.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (Sse2.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (Sse2.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class SimpleBinaryOpTest__CompareEqualSByte
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle2;
private GCHandle outHandle;
private ulong alignment;
public DataTable(SByte[] inArray1, SByte[] inArray2, SByte[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<SByte>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<SByte>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<SByte>();
if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<SByte, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<SByte, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<SByte> _fld1;
public Vector128<SByte> _fld2;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref testStruct._fld1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref testStruct._fld2), ref Unsafe.As<SByte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
return testStruct;
}
public void RunStructFldScenario(SimpleBinaryOpTest__CompareEqualSByte testClass)
{
var result = Sse2.CompareEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareEqualSByte testClass)
{
fixed (Vector128<SByte>* pFld1 = &_fld1)
fixed (Vector128<SByte>* pFld2 = &_fld2)
{
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(pFld1)),
Sse2.LoadVector128((SByte*)(pFld2))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<SByte>>() / sizeof(SByte);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector128<SByte>>() / sizeof(SByte);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector128<SByte>>() / sizeof(SByte);
private static SByte[] _data1 = new SByte[Op1ElementCount];
private static SByte[] _data2 = new SByte[Op2ElementCount];
private static Vector128<SByte> _clsVar1;
private static Vector128<SByte> _clsVar2;
private Vector128<SByte> _fld1;
private Vector128<SByte> _fld2;
private DataTable _dataTable;
static SimpleBinaryOpTest__CompareEqualSByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref _clsVar1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref _clsVar2), ref Unsafe.As<SByte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
}
public SimpleBinaryOpTest__CompareEqualSByte()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref _fld1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref _fld2), ref Unsafe.As<SByte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSByte(); }
_dataTable = new DataTable(_data1, _data2, new SByte[RetElementCount], LargestVectorSize);
}
public bool IsSupported => Sse2.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = Sse2.CompareEqual(
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray2Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
var result = Sse2.CompareEqual(
Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray2Ptr)
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<SByte>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<SByte>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<SByte>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = Sse2.CompareEqual(
_clsVar1,
_clsVar2
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<SByte>* pClsVar1 = &_clsVar1)
fixed (Vector128<SByte>* pClsVar2 = &_clsVar2)
{
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(pClsVar1)),
Sse2.LoadVector128((SByte*)(pClsVar2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector128<SByte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<SByte>>(_dataTable.inArray2Ptr);
var result = Sse2.CompareEqual(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr));
var op2 = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr));
var result = Sse2.CompareEqual(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned));
var op1 = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr));
var op2 = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr));
var result = Sse2.CompareEqual(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleBinaryOpTest__CompareEqualSByte();
var result = Sse2.CompareEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleBinaryOpTest__CompareEqualSByte();
fixed (Vector128<SByte>* pFld1 = &test._fld1)
fixed (Vector128<SByte>* pFld2 = &test._fld2)
{
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(pFld1)),
Sse2.LoadVector128((SByte*)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = Sse2.CompareEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<SByte>* pFld1 = &_fld1)
fixed (Vector128<SByte>* pFld2 = &_fld2)
{
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(pFld1)),
Sse2.LoadVector128((SByte*)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = Sse2.CompareEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(&test._fld1)),
Sse2.LoadVector128((SByte*)(&test._fld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<SByte> op1, Vector128<SByte> op2, void* result, [CallerMemberName] string method = "")
{
SByte[] inArray1 = new SByte[Op1ElementCount];
SByte[] inArray2 = new SByte[Op2ElementCount];
SByte[] outArray = new SByte[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref inArray2[0]), op2);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<SByte>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(void* op1, void* op2, void* result, [CallerMemberName] string method = "")
{
SByte[] inArray1 = new SByte[Op1ElementCount];
SByte[] inArray2 = new SByte[Op2ElementCount];
SByte[] outArray = new SByte[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<SByte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<Vector128<SByte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<SByte>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (result[0] != ((left[0] == right[0]) ? unchecked((sbyte)(-1)) : 0))
{
succeeded = false;
}
else
{
for (var i = 1; i < RetElementCount; i++)
{
if (result[i] != ((left[i] == right[i]) ? unchecked((sbyte)(-1)) : 0))
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqual)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;
namespace JIT.HardwareIntrinsics.X86
{
public static partial class Program
{
private static void CompareEqualSByte()
{
var test = new SimpleBinaryOpTest__CompareEqualSByte();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (Sse2.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
// Validates basic functionality works, using LoadAligned
test.RunBasicScenario_LoadAligned();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (Sse2.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
// Validates calling via reflection works, using LoadAligned
test.RunReflectionScenario_LoadAligned();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (Sse2.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (Sse2.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
// Validates passing a local works, using LoadAligned
test.RunLclVarScenario_LoadAligned();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (Sse2.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (Sse2.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (Sse2.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (Sse2.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class SimpleBinaryOpTest__CompareEqualSByte
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle2;
private GCHandle outHandle;
private ulong alignment;
public DataTable(SByte[] inArray1, SByte[] inArray2, SByte[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<SByte>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<SByte>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<SByte>();
if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<SByte, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<SByte, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<SByte> _fld1;
public Vector128<SByte> _fld2;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref testStruct._fld1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref testStruct._fld2), ref Unsafe.As<SByte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
return testStruct;
}
public void RunStructFldScenario(SimpleBinaryOpTest__CompareEqualSByte testClass)
{
var result = Sse2.CompareEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareEqualSByte testClass)
{
fixed (Vector128<SByte>* pFld1 = &_fld1)
fixed (Vector128<SByte>* pFld2 = &_fld2)
{
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(pFld1)),
Sse2.LoadVector128((SByte*)(pFld2))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<SByte>>() / sizeof(SByte);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector128<SByte>>() / sizeof(SByte);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector128<SByte>>() / sizeof(SByte);
private static SByte[] _data1 = new SByte[Op1ElementCount];
private static SByte[] _data2 = new SByte[Op2ElementCount];
private static Vector128<SByte> _clsVar1;
private static Vector128<SByte> _clsVar2;
private Vector128<SByte> _fld1;
private Vector128<SByte> _fld2;
private DataTable _dataTable;
static SimpleBinaryOpTest__CompareEqualSByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref _clsVar1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref _clsVar2), ref Unsafe.As<SByte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
}
public SimpleBinaryOpTest__CompareEqualSByte()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref _fld1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref _fld2), ref Unsafe.As<SByte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSByte(); }
_dataTable = new DataTable(_data1, _data2, new SByte[RetElementCount], LargestVectorSize);
}
public bool IsSupported => Sse2.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = Sse2.CompareEqual(
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray2Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
var result = Sse2.CompareEqual(
Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray2Ptr)
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<SByte>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<SByte>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<SByte>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = Sse2.CompareEqual(
_clsVar1,
_clsVar2
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<SByte>* pClsVar1 = &_clsVar1)
fixed (Vector128<SByte>* pClsVar2 = &_clsVar2)
{
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(pClsVar1)),
Sse2.LoadVector128((SByte*)(pClsVar2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector128<SByte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<SByte>>(_dataTable.inArray2Ptr);
var result = Sse2.CompareEqual(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr));
var op2 = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr));
var result = Sse2.CompareEqual(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned));
var op1 = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr));
var op2 = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr));
var result = Sse2.CompareEqual(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleBinaryOpTest__CompareEqualSByte();
var result = Sse2.CompareEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleBinaryOpTest__CompareEqualSByte();
fixed (Vector128<SByte>* pFld1 = &test._fld1)
fixed (Vector128<SByte>* pFld2 = &test._fld2)
{
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(pFld1)),
Sse2.LoadVector128((SByte*)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = Sse2.CompareEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<SByte>* pFld1 = &_fld1)
fixed (Vector128<SByte>* pFld2 = &_fld2)
{
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(pFld1)),
Sse2.LoadVector128((SByte*)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = Sse2.CompareEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = Sse2.CompareEqual(
Sse2.LoadVector128((SByte*)(&test._fld1)),
Sse2.LoadVector128((SByte*)(&test._fld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<SByte> op1, Vector128<SByte> op2, void* result, [CallerMemberName] string method = "")
{
SByte[] inArray1 = new SByte[Op1ElementCount];
SByte[] inArray2 = new SByte[Op2ElementCount];
SByte[] outArray = new SByte[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref inArray2[0]), op2);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<SByte>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(void* op1, void* op2, void* result, [CallerMemberName] string method = "")
{
SByte[] inArray1 = new SByte[Op1ElementCount];
SByte[] inArray2 = new SByte[Op2ElementCount];
SByte[] outArray = new SByte[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<SByte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<Vector128<SByte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<SByte>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (result[0] != ((left[0] == right[0]) ? unchecked((sbyte)(-1)) : 0))
{
succeeded = false;
}
else
{
for (var i = 1; i < RetElementCount; i++)
{
if (result[i] != ((left[i] == right[i]) ? unchecked((sbyte)(-1)) : 0))
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqual)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/tests/JIT/Methodical/NaN/r8NaNsub_cs_d.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>Full</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="r8NaNsub.cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>Full</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="r8NaNsub.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Private.Xml/tests/XmlWriter/WriteWithEncoding.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Xsl;
using Xunit;
namespace System.Xml.Tests
{
public class XmlWriterTests_Encoding
{
[Fact]
public static void WriteWithEncoding()
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
XmlWriterSettings settings = new XmlWriterSettings();
settings.OmitXmlDeclaration = true;
settings.ConformanceLevel = ConformanceLevel.Fragment;
settings.CloseOutput = false;
settings.Encoding = Encoding.GetEncoding("Windows-1252");
MemoryStream strm = new MemoryStream();
using (XmlWriter writer = XmlWriter.Create(strm, settings))
{
writer.WriteElementString("orderID", "1-456-ab\u0661");
writer.WriteElementString("orderID", "2-36-00a\uD800\uDC00\uD801\uDC01");
writer.Flush();
}
strm.Seek(0, SeekOrigin.Begin);
byte[] bytes = new byte[strm.Length];
int bytesCount = strm.Read(bytes, 0, (int)strm.Length);
string s = settings.Encoding.GetString(bytes, 0, bytesCount);
Assert.Equal("<orderID>1-456-ab١</orderID><orderID>2-36-00a𐀀𐐁</orderID>", s);
}
[Fact]
public void WriteWithUtf32EncodingNoBom()
{
//Given, encoding set to UTF32 with no BOM
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
ConformanceLevel = ConformanceLevel.Document,
Encoding = new UTF32Encoding(false, false, true)
};
string resultString;
using (var result = new MemoryStream())
{
// BOM can be written in this call
var writer = XmlWriter.Create(result, settings);
// When, do work and get result
writer.WriteStartDocument();
writer.WriteStartElement("orders");
writer.WriteElementString("orderID", "1-456-ab\u0661");
writer.WriteElementString("orderID", "2-36-00a\uD800\uDC00\uD801\uDC01");
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
result.Position = 0;
resultString = settings.Encoding.GetString(result.ToArray());
}
// Then, last '>' will be cut off in resulting string if BOM is present
Assert.Equal("<?xml version=\"1.0\" encoding=\"utf-32\"?>", string.Concat(resultString.Take(39)));
}
[Fact]
public static async Task AsyncSyncWrite_StreamResult_ShouldMatch()
{
using (var syncStream = new MemoryStream())
using (var asyncStream = new MemoryStream())
{
await using (var writer = XmlWriter.Create(asyncStream, new XmlWriterSettings() { Async = true }))
{
await writer.WriteStartDocumentAsync();
await writer.WriteStartElementAsync(string.Empty, "root", null);
await writer.WriteStartElementAsync(null, "test", null);
await writer.WriteAttributeStringAsync(string.Empty, "abc", string.Empty, "1");
await writer.WriteStringAsync("value");
await writer.WriteEndElementAsync();
await writer.WriteEndElementAsync();
}
using (var writer = XmlWriter.Create(syncStream, new XmlWriterSettings() { Async = false }))
{
writer.WriteStartDocument();
writer.WriteStartElement("root");
writer.WriteStartElement("test");
writer.WriteAttributeString("abc", "1");
writer.WriteString("value");
writer.WriteEndElement();
writer.WriteEndElement();
}
Assert.Equal(syncStream.ToArray(), asyncStream.ToArray());
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Xsl;
using Xunit;
namespace System.Xml.Tests
{
public class XmlWriterTests_Encoding
{
[Fact]
public static void WriteWithEncoding()
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
XmlWriterSettings settings = new XmlWriterSettings();
settings.OmitXmlDeclaration = true;
settings.ConformanceLevel = ConformanceLevel.Fragment;
settings.CloseOutput = false;
settings.Encoding = Encoding.GetEncoding("Windows-1252");
MemoryStream strm = new MemoryStream();
using (XmlWriter writer = XmlWriter.Create(strm, settings))
{
writer.WriteElementString("orderID", "1-456-ab\u0661");
writer.WriteElementString("orderID", "2-36-00a\uD800\uDC00\uD801\uDC01");
writer.Flush();
}
strm.Seek(0, SeekOrigin.Begin);
byte[] bytes = new byte[strm.Length];
int bytesCount = strm.Read(bytes, 0, (int)strm.Length);
string s = settings.Encoding.GetString(bytes, 0, bytesCount);
Assert.Equal("<orderID>1-456-ab١</orderID><orderID>2-36-00a𐀀𐐁</orderID>", s);
}
[Fact]
public void WriteWithUtf32EncodingNoBom()
{
//Given, encoding set to UTF32 with no BOM
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
ConformanceLevel = ConformanceLevel.Document,
Encoding = new UTF32Encoding(false, false, true)
};
string resultString;
using (var result = new MemoryStream())
{
// BOM can be written in this call
var writer = XmlWriter.Create(result, settings);
// When, do work and get result
writer.WriteStartDocument();
writer.WriteStartElement("orders");
writer.WriteElementString("orderID", "1-456-ab\u0661");
writer.WriteElementString("orderID", "2-36-00a\uD800\uDC00\uD801\uDC01");
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
result.Position = 0;
resultString = settings.Encoding.GetString(result.ToArray());
}
// Then, last '>' will be cut off in resulting string if BOM is present
Assert.Equal("<?xml version=\"1.0\" encoding=\"utf-32\"?>", string.Concat(resultString.Take(39)));
}
[Fact]
public static async Task AsyncSyncWrite_StreamResult_ShouldMatch()
{
using (var syncStream = new MemoryStream())
using (var asyncStream = new MemoryStream())
{
await using (var writer = XmlWriter.Create(asyncStream, new XmlWriterSettings() { Async = true }))
{
await writer.WriteStartDocumentAsync();
await writer.WriteStartElementAsync(string.Empty, "root", null);
await writer.WriteStartElementAsync(null, "test", null);
await writer.WriteAttributeStringAsync(string.Empty, "abc", string.Empty, "1");
await writer.WriteStringAsync("value");
await writer.WriteEndElementAsync();
await writer.WriteEndElementAsync();
}
using (var writer = XmlWriter.Create(syncStream, new XmlWriterSettings() { Async = false }))
{
writer.WriteStartDocument();
writer.WriteStartElement("root");
writer.WriteStartElement("test");
writer.WriteAttributeString("abc", "1");
writer.WriteString("value");
writer.WriteEndElement();
writer.WriteEndElement();
}
Assert.Equal(syncStream.ToArray(), asyncStream.ToArray());
}
}
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Linq.Expressions/tests/Lambda/LambdaMultiplyTests.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Xunit;
namespace System.Linq.Expressions.Tests
{
public static class LambdaMultiplyTests
{
#region Test methods
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyDecimalTest(bool useInterpreter)
{
decimal[] values = new decimal[] { decimal.Zero, decimal.One, decimal.MinusOne, decimal.MinValue, decimal.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyDecimal(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyDoubleTest(bool useInterpreter)
{
double[] values = new double[] { 0, 1, -1, double.MinValue, double.MaxValue, double.Epsilon, double.NegativeInfinity, double.PositiveInfinity, double.NaN };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyDouble(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyFloatTest(bool useInterpreter)
{
float[] values = new float[] { 0, 1, -1, float.MinValue, float.MaxValue, float.Epsilon, float.NegativeInfinity, float.PositiveInfinity, float.NaN };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyFloat(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyIntTest(bool useInterpreter)
{
int[] values = new int[] { 0, 1, -1, int.MinValue, int.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyInt(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyLongTest(bool useInterpreter)
{
long[] values = new long[] { 0, 1, -1, long.MinValue, long.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyLong(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyShortTest(bool useInterpreter)
{
short[] values = new short[] { 0, 1, -1, short.MinValue, short.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyShort(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyUIntTest(bool useInterpreter)
{
uint[] values = new uint[] { 0, 1, uint.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyUInt(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyULongTest(bool useInterpreter)
{
ulong[] values = new ulong[] { 0, 1, ulong.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyULong(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyUShortTest(bool useInterpreter)
{
ushort[] values = new ushort[] { 0, 1, ushort.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyUShort(values[i], values[j], useInterpreter);
}
}
}
#endregion
#region Test verifiers
#region Verify decimal
private static void VerifyMultiplyDecimal(decimal a, decimal b, bool useInterpreter)
{
bool overflows;
decimal expected;
try
{
expected = a * b;
overflows = false;
}
catch
{
expected = 0;
overflows = true;
}
ParameterExpression p0 = Expression.Parameter(typeof(decimal), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(decimal), "p1");
// verify with parameters supplied
Expression<Func<decimal>> e1 =
Expression.Lambda<Func<decimal>>(
Expression.Invoke(
Expression.Lambda<Func<decimal, decimal, decimal>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(decimal)),
Expression.Constant(b, typeof(decimal))
}),
Enumerable.Empty<ParameterExpression>());
Func<decimal> f1 = e1.Compile(useInterpreter);
if (overflows)
{
Assert.Throws<OverflowException>(() => f1());
}
else
{
Assert.Equal(expected, f1());
}
// verify with values passed to make parameters
Expression<Func<decimal, decimal, Func<decimal>>> e2 =
Expression.Lambda<Func<decimal, decimal, Func<decimal>>>(
Expression.Lambda<Func<decimal>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<decimal, decimal, Func<decimal>> f2 = e2.Compile(useInterpreter);
if (overflows)
{
Assert.Throws<OverflowException>(() => f2(a, b)());
}
else
{
Assert.Equal(expected, f2(a, b)());
}
// verify with values directly passed
Expression<Func<Func<decimal, decimal, decimal>>> e3 =
Expression.Lambda<Func<Func<decimal, decimal, decimal>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<decimal, decimal, decimal>>>(
Expression.Lambda<Func<decimal, decimal, decimal>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<decimal, decimal, decimal> f3 = e3.Compile(useInterpreter)();
if (overflows)
{
Assert.Throws<OverflowException>(() => f3(a, b));
}
else
{
Assert.Equal(expected, f3(a, b));
}
// verify as a function generator
Expression<Func<Func<decimal, decimal, decimal>>> e4 =
Expression.Lambda<Func<Func<decimal, decimal, decimal>>>(
Expression.Lambda<Func<decimal, decimal, decimal>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<decimal, decimal, decimal>> f4 = e4.Compile(useInterpreter);
if (overflows)
{
Assert.Throws<OverflowException>(() => f4()(a, b));
}
else
{
Assert.Equal(expected, f4()(a, b));
}
// verify with currying
Expression<Func<decimal, Func<decimal, decimal>>> e5 =
Expression.Lambda<Func<decimal, Func<decimal, decimal>>>(
Expression.Lambda<Func<decimal, decimal>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<decimal, Func<decimal, decimal>> f5 = e5.Compile(useInterpreter);
if (overflows)
{
Assert.Throws<OverflowException>(() => f5(a)(b));
}
else
{
Assert.Equal(expected, f5(a)(b));
}
// verify with one parameter
Expression<Func<Func<decimal, decimal>>> e6 =
Expression.Lambda<Func<Func<decimal, decimal>>>(
Expression.Invoke(
Expression.Lambda<Func<decimal, Func<decimal, decimal>>>(
Expression.Lambda<Func<decimal, decimal>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(decimal)) }),
Enumerable.Empty<ParameterExpression>());
Func<decimal, decimal> f6 = e6.Compile(useInterpreter)();
if (overflows)
{
Assert.Throws<OverflowException>(() => f6(b));
}
else
{
Assert.Equal(expected, f6(b));
}
}
#endregion
#region Verify double
private static void VerifyMultiplyDouble(double a, double b, bool useInterpreter)
{
double expected = a * b;
ParameterExpression p0 = Expression.Parameter(typeof(double), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(double), "p1");
// verify with parameters supplied
Expression<Func<double>> e1 =
Expression.Lambda<Func<double>>(
Expression.Invoke(
Expression.Lambda<Func<double, double, double>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(double)),
Expression.Constant(b, typeof(double))
}),
Enumerable.Empty<ParameterExpression>());
Func<double> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<double, double, Func<double>>> e2 =
Expression.Lambda<Func<double, double, Func<double>>>(
Expression.Lambda<Func<double>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<double, double, Func<double>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<double, double, double>>> e3 =
Expression.Lambda<Func<Func<double, double, double>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<double, double, double>>>(
Expression.Lambda<Func<double, double, double>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<double, double, double> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<double, double, double>>> e4 =
Expression.Lambda<Func<Func<double, double, double>>>(
Expression.Lambda<Func<double, double, double>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<double, double, double>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<double, Func<double, double>>> e5 =
Expression.Lambda<Func<double, Func<double, double>>>(
Expression.Lambda<Func<double, double>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<double, Func<double, double>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<double, double>>> e6 =
Expression.Lambda<Func<Func<double, double>>>(
Expression.Invoke(
Expression.Lambda<Func<double, Func<double, double>>>(
Expression.Lambda<Func<double, double>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(double)) }),
Enumerable.Empty<ParameterExpression>());
Func<double, double> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify float
private static void VerifyMultiplyFloat(float a, float b, bool useInterpreter)
{
float expected = a * b;
ParameterExpression p0 = Expression.Parameter(typeof(float), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(float), "p1");
// verify with parameters supplied
Expression<Func<float>> e1 =
Expression.Lambda<Func<float>>(
Expression.Invoke(
Expression.Lambda<Func<float, float, float>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(float)),
Expression.Constant(b, typeof(float))
}),
Enumerable.Empty<ParameterExpression>());
Func<float> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<float, float, Func<float>>> e2 =
Expression.Lambda<Func<float, float, Func<float>>>(
Expression.Lambda<Func<float>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<float, float, Func<float>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<float, float, float>>> e3 =
Expression.Lambda<Func<Func<float, float, float>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<float, float, float>>>(
Expression.Lambda<Func<float, float, float>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<float, float, float> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<float, float, float>>> e4 =
Expression.Lambda<Func<Func<float, float, float>>>(
Expression.Lambda<Func<float, float, float>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<float, float, float>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<float, Func<float, float>>> e5 =
Expression.Lambda<Func<float, Func<float, float>>>(
Expression.Lambda<Func<float, float>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<float, Func<float, float>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<float, float>>> e6 =
Expression.Lambda<Func<Func<float, float>>>(
Expression.Invoke(
Expression.Lambda<Func<float, Func<float, float>>>(
Expression.Lambda<Func<float, float>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(float)) }),
Enumerable.Empty<ParameterExpression>());
Func<float, float> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify int
private static void VerifyMultiplyInt(int a, int b, bool useInterpreter)
{
int expected = unchecked(a * b);
ParameterExpression p0 = Expression.Parameter(typeof(int), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(int), "p1");
// verify with parameters supplied
Expression<Func<int>> e1 =
Expression.Lambda<Func<int>>(
Expression.Invoke(
Expression.Lambda<Func<int, int, int>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(int)),
Expression.Constant(b, typeof(int))
}),
Enumerable.Empty<ParameterExpression>());
Func<int> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<int, int, Func<int>>> e2 =
Expression.Lambda<Func<int, int, Func<int>>>(
Expression.Lambda<Func<int>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<int, int, Func<int>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<int, int, int>>> e3 =
Expression.Lambda<Func<Func<int, int, int>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<int, int, int>>>(
Expression.Lambda<Func<int, int, int>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<int, int, int> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<int, int, int>>> e4 =
Expression.Lambda<Func<Func<int, int, int>>>(
Expression.Lambda<Func<int, int, int>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<int, int, int>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<int, Func<int, int>>> e5 =
Expression.Lambda<Func<int, Func<int, int>>>(
Expression.Lambda<Func<int, int>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<int, Func<int, int>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<int, int>>> e6 =
Expression.Lambda<Func<Func<int, int>>>(
Expression.Invoke(
Expression.Lambda<Func<int, Func<int, int>>>(
Expression.Lambda<Func<int, int>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(int)) }),
Enumerable.Empty<ParameterExpression>());
Func<int, int> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify long
private static void VerifyMultiplyLong(long a, long b, bool useInterpreter)
{
long expected = unchecked(a * b);
ParameterExpression p0 = Expression.Parameter(typeof(long), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(long), "p1");
// verify with parameters supplied
Expression<Func<long>> e1 =
Expression.Lambda<Func<long>>(
Expression.Invoke(
Expression.Lambda<Func<long, long, long>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(long)),
Expression.Constant(b, typeof(long))
}),
Enumerable.Empty<ParameterExpression>());
Func<long> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<long, long, Func<long>>> e2 =
Expression.Lambda<Func<long, long, Func<long>>>(
Expression.Lambda<Func<long>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<long, long, Func<long>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<long, long, long>>> e3 =
Expression.Lambda<Func<Func<long, long, long>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<long, long, long>>>(
Expression.Lambda<Func<long, long, long>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<long, long, long> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<long, long, long>>> e4 =
Expression.Lambda<Func<Func<long, long, long>>>(
Expression.Lambda<Func<long, long, long>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<long, long, long>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<long, Func<long, long>>> e5 =
Expression.Lambda<Func<long, Func<long, long>>>(
Expression.Lambda<Func<long, long>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<long, Func<long, long>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<long, long>>> e6 =
Expression.Lambda<Func<Func<long, long>>>(
Expression.Invoke(
Expression.Lambda<Func<long, Func<long, long>>>(
Expression.Lambda<Func<long, long>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(long)) }),
Enumerable.Empty<ParameterExpression>());
Func<long, long> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify short
private static void VerifyMultiplyShort(short a, short b, bool useInterpreter)
{
short expected = unchecked((short)(a * b));
ParameterExpression p0 = Expression.Parameter(typeof(short), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(short), "p1");
// verify with parameters supplied
Expression<Func<short>> e1 =
Expression.Lambda<Func<short>>(
Expression.Invoke(
Expression.Lambda<Func<short, short, short>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(short)),
Expression.Constant(b, typeof(short))
}),
Enumerable.Empty<ParameterExpression>());
Func<short> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<short, short, Func<short>>> e2 =
Expression.Lambda<Func<short, short, Func<short>>>(
Expression.Lambda<Func<short>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<short, short, Func<short>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<short, short, short>>> e3 =
Expression.Lambda<Func<Func<short, short, short>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<short, short, short>>>(
Expression.Lambda<Func<short, short, short>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<short, short, short> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<short, short, short>>> e4 =
Expression.Lambda<Func<Func<short, short, short>>>(
Expression.Lambda<Func<short, short, short>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<short, short, short>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<short, Func<short, short>>> e5 =
Expression.Lambda<Func<short, Func<short, short>>>(
Expression.Lambda<Func<short, short>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<short, Func<short, short>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<short, short>>> e6 =
Expression.Lambda<Func<Func<short, short>>>(
Expression.Invoke(
Expression.Lambda<Func<short, Func<short, short>>>(
Expression.Lambda<Func<short, short>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(short)) }),
Enumerable.Empty<ParameterExpression>());
Func<short, short> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify uint
private static void VerifyMultiplyUInt(uint a, uint b, bool useInterpreter)
{
uint expected = unchecked(a * b);
ParameterExpression p0 = Expression.Parameter(typeof(uint), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(uint), "p1");
// verify with parameters supplied
Expression<Func<uint>> e1 =
Expression.Lambda<Func<uint>>(
Expression.Invoke(
Expression.Lambda<Func<uint, uint, uint>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(uint)),
Expression.Constant(b, typeof(uint))
}),
Enumerable.Empty<ParameterExpression>());
Func<uint> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<uint, uint, Func<uint>>> e2 =
Expression.Lambda<Func<uint, uint, Func<uint>>>(
Expression.Lambda<Func<uint>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<uint, uint, Func<uint>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<uint, uint, uint>>> e3 =
Expression.Lambda<Func<Func<uint, uint, uint>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<uint, uint, uint>>>(
Expression.Lambda<Func<uint, uint, uint>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<uint, uint, uint> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<uint, uint, uint>>> e4 =
Expression.Lambda<Func<Func<uint, uint, uint>>>(
Expression.Lambda<Func<uint, uint, uint>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<uint, uint, uint>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<uint, Func<uint, uint>>> e5 =
Expression.Lambda<Func<uint, Func<uint, uint>>>(
Expression.Lambda<Func<uint, uint>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<uint, Func<uint, uint>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<uint, uint>>> e6 =
Expression.Lambda<Func<Func<uint, uint>>>(
Expression.Invoke(
Expression.Lambda<Func<uint, Func<uint, uint>>>(
Expression.Lambda<Func<uint, uint>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(uint)) }),
Enumerable.Empty<ParameterExpression>());
Func<uint, uint> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify ulong
private static void VerifyMultiplyULong(ulong a, ulong b, bool useInterpreter)
{
ulong expected = unchecked(a * b);
ParameterExpression p0 = Expression.Parameter(typeof(ulong), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(ulong), "p1");
// verify with parameters supplied
Expression<Func<ulong>> e1 =
Expression.Lambda<Func<ulong>>(
Expression.Invoke(
Expression.Lambda<Func<ulong, ulong, ulong>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(ulong)),
Expression.Constant(b, typeof(ulong))
}),
Enumerable.Empty<ParameterExpression>());
Func<ulong> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<ulong, ulong, Func<ulong>>> e2 =
Expression.Lambda<Func<ulong, ulong, Func<ulong>>>(
Expression.Lambda<Func<ulong>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<ulong, ulong, Func<ulong>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<ulong, ulong, ulong>>> e3 =
Expression.Lambda<Func<Func<ulong, ulong, ulong>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<ulong, ulong, ulong>>>(
Expression.Lambda<Func<ulong, ulong, ulong>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<ulong, ulong, ulong> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<ulong, ulong, ulong>>> e4 =
Expression.Lambda<Func<Func<ulong, ulong, ulong>>>(
Expression.Lambda<Func<ulong, ulong, ulong>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<ulong, ulong, ulong>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<ulong, Func<ulong, ulong>>> e5 =
Expression.Lambda<Func<ulong, Func<ulong, ulong>>>(
Expression.Lambda<Func<ulong, ulong>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<ulong, Func<ulong, ulong>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<ulong, ulong>>> e6 =
Expression.Lambda<Func<Func<ulong, ulong>>>(
Expression.Invoke(
Expression.Lambda<Func<ulong, Func<ulong, ulong>>>(
Expression.Lambda<Func<ulong, ulong>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(ulong)) }),
Enumerable.Empty<ParameterExpression>());
Func<ulong, ulong> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify ushort
private static void VerifyMultiplyUShort(ushort a, ushort b, bool useInterpreter)
{
ushort expected = unchecked((ushort)(a * b));
ParameterExpression p0 = Expression.Parameter(typeof(ushort), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(ushort), "p1");
// verify with parameters supplied
Expression<Func<ushort>> e1 =
Expression.Lambda<Func<ushort>>(
Expression.Invoke(
Expression.Lambda<Func<ushort, ushort, ushort>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(ushort)),
Expression.Constant(b, typeof(ushort))
}),
Enumerable.Empty<ParameterExpression>());
Func<ushort> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<ushort, ushort, Func<ushort>>> e2 =
Expression.Lambda<Func<ushort, ushort, Func<ushort>>>(
Expression.Lambda<Func<ushort>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<ushort, ushort, Func<ushort>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<ushort, ushort, ushort>>> e3 =
Expression.Lambda<Func<Func<ushort, ushort, ushort>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<ushort, ushort, ushort>>>(
Expression.Lambda<Func<ushort, ushort, ushort>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<ushort, ushort, ushort> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<ushort, ushort, ushort>>> e4 =
Expression.Lambda<Func<Func<ushort, ushort, ushort>>>(
Expression.Lambda<Func<ushort, ushort, ushort>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<ushort, ushort, ushort>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<ushort, Func<ushort, ushort>>> e5 =
Expression.Lambda<Func<ushort, Func<ushort, ushort>>>(
Expression.Lambda<Func<ushort, ushort>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<ushort, Func<ushort, ushort>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<ushort, ushort>>> e6 =
Expression.Lambda<Func<Func<ushort, ushort>>>(
Expression.Invoke(
Expression.Lambda<Func<ushort, Func<ushort, ushort>>>(
Expression.Lambda<Func<ushort, ushort>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(ushort)) }),
Enumerable.Empty<ParameterExpression>());
Func<ushort, ushort> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#endregion
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Xunit;
namespace System.Linq.Expressions.Tests
{
public static class LambdaMultiplyTests
{
#region Test methods
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyDecimalTest(bool useInterpreter)
{
decimal[] values = new decimal[] { decimal.Zero, decimal.One, decimal.MinusOne, decimal.MinValue, decimal.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyDecimal(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyDoubleTest(bool useInterpreter)
{
double[] values = new double[] { 0, 1, -1, double.MinValue, double.MaxValue, double.Epsilon, double.NegativeInfinity, double.PositiveInfinity, double.NaN };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyDouble(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyFloatTest(bool useInterpreter)
{
float[] values = new float[] { 0, 1, -1, float.MinValue, float.MaxValue, float.Epsilon, float.NegativeInfinity, float.PositiveInfinity, float.NaN };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyFloat(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyIntTest(bool useInterpreter)
{
int[] values = new int[] { 0, 1, -1, int.MinValue, int.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyInt(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyLongTest(bool useInterpreter)
{
long[] values = new long[] { 0, 1, -1, long.MinValue, long.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyLong(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyShortTest(bool useInterpreter)
{
short[] values = new short[] { 0, 1, -1, short.MinValue, short.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyShort(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyUIntTest(bool useInterpreter)
{
uint[] values = new uint[] { 0, 1, uint.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyUInt(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyULongTest(bool useInterpreter)
{
ulong[] values = new ulong[] { 0, 1, ulong.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyULong(values[i], values[j], useInterpreter);
}
}
}
[Theory, ClassData(typeof(CompilationTypes))]
public static void LambdaMultiplyUShortTest(bool useInterpreter)
{
ushort[] values = new ushort[] { 0, 1, ushort.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyMultiplyUShort(values[i], values[j], useInterpreter);
}
}
}
#endregion
#region Test verifiers
#region Verify decimal
private static void VerifyMultiplyDecimal(decimal a, decimal b, bool useInterpreter)
{
bool overflows;
decimal expected;
try
{
expected = a * b;
overflows = false;
}
catch
{
expected = 0;
overflows = true;
}
ParameterExpression p0 = Expression.Parameter(typeof(decimal), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(decimal), "p1");
// verify with parameters supplied
Expression<Func<decimal>> e1 =
Expression.Lambda<Func<decimal>>(
Expression.Invoke(
Expression.Lambda<Func<decimal, decimal, decimal>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(decimal)),
Expression.Constant(b, typeof(decimal))
}),
Enumerable.Empty<ParameterExpression>());
Func<decimal> f1 = e1.Compile(useInterpreter);
if (overflows)
{
Assert.Throws<OverflowException>(() => f1());
}
else
{
Assert.Equal(expected, f1());
}
// verify with values passed to make parameters
Expression<Func<decimal, decimal, Func<decimal>>> e2 =
Expression.Lambda<Func<decimal, decimal, Func<decimal>>>(
Expression.Lambda<Func<decimal>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<decimal, decimal, Func<decimal>> f2 = e2.Compile(useInterpreter);
if (overflows)
{
Assert.Throws<OverflowException>(() => f2(a, b)());
}
else
{
Assert.Equal(expected, f2(a, b)());
}
// verify with values directly passed
Expression<Func<Func<decimal, decimal, decimal>>> e3 =
Expression.Lambda<Func<Func<decimal, decimal, decimal>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<decimal, decimal, decimal>>>(
Expression.Lambda<Func<decimal, decimal, decimal>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<decimal, decimal, decimal> f3 = e3.Compile(useInterpreter)();
if (overflows)
{
Assert.Throws<OverflowException>(() => f3(a, b));
}
else
{
Assert.Equal(expected, f3(a, b));
}
// verify as a function generator
Expression<Func<Func<decimal, decimal, decimal>>> e4 =
Expression.Lambda<Func<Func<decimal, decimal, decimal>>>(
Expression.Lambda<Func<decimal, decimal, decimal>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<decimal, decimal, decimal>> f4 = e4.Compile(useInterpreter);
if (overflows)
{
Assert.Throws<OverflowException>(() => f4()(a, b));
}
else
{
Assert.Equal(expected, f4()(a, b));
}
// verify with currying
Expression<Func<decimal, Func<decimal, decimal>>> e5 =
Expression.Lambda<Func<decimal, Func<decimal, decimal>>>(
Expression.Lambda<Func<decimal, decimal>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<decimal, Func<decimal, decimal>> f5 = e5.Compile(useInterpreter);
if (overflows)
{
Assert.Throws<OverflowException>(() => f5(a)(b));
}
else
{
Assert.Equal(expected, f5(a)(b));
}
// verify with one parameter
Expression<Func<Func<decimal, decimal>>> e6 =
Expression.Lambda<Func<Func<decimal, decimal>>>(
Expression.Invoke(
Expression.Lambda<Func<decimal, Func<decimal, decimal>>>(
Expression.Lambda<Func<decimal, decimal>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(decimal)) }),
Enumerable.Empty<ParameterExpression>());
Func<decimal, decimal> f6 = e6.Compile(useInterpreter)();
if (overflows)
{
Assert.Throws<OverflowException>(() => f6(b));
}
else
{
Assert.Equal(expected, f6(b));
}
}
#endregion
#region Verify double
private static void VerifyMultiplyDouble(double a, double b, bool useInterpreter)
{
double expected = a * b;
ParameterExpression p0 = Expression.Parameter(typeof(double), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(double), "p1");
// verify with parameters supplied
Expression<Func<double>> e1 =
Expression.Lambda<Func<double>>(
Expression.Invoke(
Expression.Lambda<Func<double, double, double>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(double)),
Expression.Constant(b, typeof(double))
}),
Enumerable.Empty<ParameterExpression>());
Func<double> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<double, double, Func<double>>> e2 =
Expression.Lambda<Func<double, double, Func<double>>>(
Expression.Lambda<Func<double>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<double, double, Func<double>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<double, double, double>>> e3 =
Expression.Lambda<Func<Func<double, double, double>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<double, double, double>>>(
Expression.Lambda<Func<double, double, double>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<double, double, double> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<double, double, double>>> e4 =
Expression.Lambda<Func<Func<double, double, double>>>(
Expression.Lambda<Func<double, double, double>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<double, double, double>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<double, Func<double, double>>> e5 =
Expression.Lambda<Func<double, Func<double, double>>>(
Expression.Lambda<Func<double, double>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<double, Func<double, double>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<double, double>>> e6 =
Expression.Lambda<Func<Func<double, double>>>(
Expression.Invoke(
Expression.Lambda<Func<double, Func<double, double>>>(
Expression.Lambda<Func<double, double>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(double)) }),
Enumerable.Empty<ParameterExpression>());
Func<double, double> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify float
private static void VerifyMultiplyFloat(float a, float b, bool useInterpreter)
{
float expected = a * b;
ParameterExpression p0 = Expression.Parameter(typeof(float), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(float), "p1");
// verify with parameters supplied
Expression<Func<float>> e1 =
Expression.Lambda<Func<float>>(
Expression.Invoke(
Expression.Lambda<Func<float, float, float>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(float)),
Expression.Constant(b, typeof(float))
}),
Enumerable.Empty<ParameterExpression>());
Func<float> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<float, float, Func<float>>> e2 =
Expression.Lambda<Func<float, float, Func<float>>>(
Expression.Lambda<Func<float>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<float, float, Func<float>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<float, float, float>>> e3 =
Expression.Lambda<Func<Func<float, float, float>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<float, float, float>>>(
Expression.Lambda<Func<float, float, float>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<float, float, float> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<float, float, float>>> e4 =
Expression.Lambda<Func<Func<float, float, float>>>(
Expression.Lambda<Func<float, float, float>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<float, float, float>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<float, Func<float, float>>> e5 =
Expression.Lambda<Func<float, Func<float, float>>>(
Expression.Lambda<Func<float, float>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<float, Func<float, float>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<float, float>>> e6 =
Expression.Lambda<Func<Func<float, float>>>(
Expression.Invoke(
Expression.Lambda<Func<float, Func<float, float>>>(
Expression.Lambda<Func<float, float>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(float)) }),
Enumerable.Empty<ParameterExpression>());
Func<float, float> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify int
private static void VerifyMultiplyInt(int a, int b, bool useInterpreter)
{
int expected = unchecked(a * b);
ParameterExpression p0 = Expression.Parameter(typeof(int), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(int), "p1");
// verify with parameters supplied
Expression<Func<int>> e1 =
Expression.Lambda<Func<int>>(
Expression.Invoke(
Expression.Lambda<Func<int, int, int>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(int)),
Expression.Constant(b, typeof(int))
}),
Enumerable.Empty<ParameterExpression>());
Func<int> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<int, int, Func<int>>> e2 =
Expression.Lambda<Func<int, int, Func<int>>>(
Expression.Lambda<Func<int>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<int, int, Func<int>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<int, int, int>>> e3 =
Expression.Lambda<Func<Func<int, int, int>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<int, int, int>>>(
Expression.Lambda<Func<int, int, int>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<int, int, int> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<int, int, int>>> e4 =
Expression.Lambda<Func<Func<int, int, int>>>(
Expression.Lambda<Func<int, int, int>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<int, int, int>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<int, Func<int, int>>> e5 =
Expression.Lambda<Func<int, Func<int, int>>>(
Expression.Lambda<Func<int, int>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<int, Func<int, int>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<int, int>>> e6 =
Expression.Lambda<Func<Func<int, int>>>(
Expression.Invoke(
Expression.Lambda<Func<int, Func<int, int>>>(
Expression.Lambda<Func<int, int>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(int)) }),
Enumerable.Empty<ParameterExpression>());
Func<int, int> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify long
private static void VerifyMultiplyLong(long a, long b, bool useInterpreter)
{
long expected = unchecked(a * b);
ParameterExpression p0 = Expression.Parameter(typeof(long), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(long), "p1");
// verify with parameters supplied
Expression<Func<long>> e1 =
Expression.Lambda<Func<long>>(
Expression.Invoke(
Expression.Lambda<Func<long, long, long>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(long)),
Expression.Constant(b, typeof(long))
}),
Enumerable.Empty<ParameterExpression>());
Func<long> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<long, long, Func<long>>> e2 =
Expression.Lambda<Func<long, long, Func<long>>>(
Expression.Lambda<Func<long>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<long, long, Func<long>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<long, long, long>>> e3 =
Expression.Lambda<Func<Func<long, long, long>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<long, long, long>>>(
Expression.Lambda<Func<long, long, long>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<long, long, long> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<long, long, long>>> e4 =
Expression.Lambda<Func<Func<long, long, long>>>(
Expression.Lambda<Func<long, long, long>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<long, long, long>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<long, Func<long, long>>> e5 =
Expression.Lambda<Func<long, Func<long, long>>>(
Expression.Lambda<Func<long, long>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<long, Func<long, long>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<long, long>>> e6 =
Expression.Lambda<Func<Func<long, long>>>(
Expression.Invoke(
Expression.Lambda<Func<long, Func<long, long>>>(
Expression.Lambda<Func<long, long>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(long)) }),
Enumerable.Empty<ParameterExpression>());
Func<long, long> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify short
private static void VerifyMultiplyShort(short a, short b, bool useInterpreter)
{
short expected = unchecked((short)(a * b));
ParameterExpression p0 = Expression.Parameter(typeof(short), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(short), "p1");
// verify with parameters supplied
Expression<Func<short>> e1 =
Expression.Lambda<Func<short>>(
Expression.Invoke(
Expression.Lambda<Func<short, short, short>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(short)),
Expression.Constant(b, typeof(short))
}),
Enumerable.Empty<ParameterExpression>());
Func<short> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<short, short, Func<short>>> e2 =
Expression.Lambda<Func<short, short, Func<short>>>(
Expression.Lambda<Func<short>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<short, short, Func<short>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<short, short, short>>> e3 =
Expression.Lambda<Func<Func<short, short, short>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<short, short, short>>>(
Expression.Lambda<Func<short, short, short>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<short, short, short> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<short, short, short>>> e4 =
Expression.Lambda<Func<Func<short, short, short>>>(
Expression.Lambda<Func<short, short, short>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<short, short, short>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<short, Func<short, short>>> e5 =
Expression.Lambda<Func<short, Func<short, short>>>(
Expression.Lambda<Func<short, short>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<short, Func<short, short>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<short, short>>> e6 =
Expression.Lambda<Func<Func<short, short>>>(
Expression.Invoke(
Expression.Lambda<Func<short, Func<short, short>>>(
Expression.Lambda<Func<short, short>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(short)) }),
Enumerable.Empty<ParameterExpression>());
Func<short, short> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify uint
private static void VerifyMultiplyUInt(uint a, uint b, bool useInterpreter)
{
uint expected = unchecked(a * b);
ParameterExpression p0 = Expression.Parameter(typeof(uint), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(uint), "p1");
// verify with parameters supplied
Expression<Func<uint>> e1 =
Expression.Lambda<Func<uint>>(
Expression.Invoke(
Expression.Lambda<Func<uint, uint, uint>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(uint)),
Expression.Constant(b, typeof(uint))
}),
Enumerable.Empty<ParameterExpression>());
Func<uint> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<uint, uint, Func<uint>>> e2 =
Expression.Lambda<Func<uint, uint, Func<uint>>>(
Expression.Lambda<Func<uint>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<uint, uint, Func<uint>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<uint, uint, uint>>> e3 =
Expression.Lambda<Func<Func<uint, uint, uint>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<uint, uint, uint>>>(
Expression.Lambda<Func<uint, uint, uint>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<uint, uint, uint> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<uint, uint, uint>>> e4 =
Expression.Lambda<Func<Func<uint, uint, uint>>>(
Expression.Lambda<Func<uint, uint, uint>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<uint, uint, uint>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<uint, Func<uint, uint>>> e5 =
Expression.Lambda<Func<uint, Func<uint, uint>>>(
Expression.Lambda<Func<uint, uint>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<uint, Func<uint, uint>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<uint, uint>>> e6 =
Expression.Lambda<Func<Func<uint, uint>>>(
Expression.Invoke(
Expression.Lambda<Func<uint, Func<uint, uint>>>(
Expression.Lambda<Func<uint, uint>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(uint)) }),
Enumerable.Empty<ParameterExpression>());
Func<uint, uint> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify ulong
private static void VerifyMultiplyULong(ulong a, ulong b, bool useInterpreter)
{
ulong expected = unchecked(a * b);
ParameterExpression p0 = Expression.Parameter(typeof(ulong), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(ulong), "p1");
// verify with parameters supplied
Expression<Func<ulong>> e1 =
Expression.Lambda<Func<ulong>>(
Expression.Invoke(
Expression.Lambda<Func<ulong, ulong, ulong>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(ulong)),
Expression.Constant(b, typeof(ulong))
}),
Enumerable.Empty<ParameterExpression>());
Func<ulong> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<ulong, ulong, Func<ulong>>> e2 =
Expression.Lambda<Func<ulong, ulong, Func<ulong>>>(
Expression.Lambda<Func<ulong>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<ulong, ulong, Func<ulong>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<ulong, ulong, ulong>>> e3 =
Expression.Lambda<Func<Func<ulong, ulong, ulong>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<ulong, ulong, ulong>>>(
Expression.Lambda<Func<ulong, ulong, ulong>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<ulong, ulong, ulong> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<ulong, ulong, ulong>>> e4 =
Expression.Lambda<Func<Func<ulong, ulong, ulong>>>(
Expression.Lambda<Func<ulong, ulong, ulong>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<ulong, ulong, ulong>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<ulong, Func<ulong, ulong>>> e5 =
Expression.Lambda<Func<ulong, Func<ulong, ulong>>>(
Expression.Lambda<Func<ulong, ulong>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<ulong, Func<ulong, ulong>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<ulong, ulong>>> e6 =
Expression.Lambda<Func<Func<ulong, ulong>>>(
Expression.Invoke(
Expression.Lambda<Func<ulong, Func<ulong, ulong>>>(
Expression.Lambda<Func<ulong, ulong>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(ulong)) }),
Enumerable.Empty<ParameterExpression>());
Func<ulong, ulong> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#region Verify ushort
private static void VerifyMultiplyUShort(ushort a, ushort b, bool useInterpreter)
{
ushort expected = unchecked((ushort)(a * b));
ParameterExpression p0 = Expression.Parameter(typeof(ushort), "p0");
ParameterExpression p1 = Expression.Parameter(typeof(ushort), "p1");
// verify with parameters supplied
Expression<Func<ushort>> e1 =
Expression.Lambda<Func<ushort>>(
Expression.Invoke(
Expression.Lambda<Func<ushort, ushort, ushort>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
new Expression[]
{
Expression.Constant(a, typeof(ushort)),
Expression.Constant(b, typeof(ushort))
}),
Enumerable.Empty<ParameterExpression>());
Func<ushort> f1 = e1.Compile(useInterpreter);
Assert.Equal(expected, f1());
// verify with values passed to make parameters
Expression<Func<ushort, ushort, Func<ushort>>> e2 =
Expression.Lambda<Func<ushort, ushort, Func<ushort>>>(
Expression.Lambda<Func<ushort>>(
Expression.Multiply(p0, p1),
Enumerable.Empty<ParameterExpression>()),
new ParameterExpression[] { p0, p1 });
Func<ushort, ushort, Func<ushort>> f2 = e2.Compile(useInterpreter);
Assert.Equal(expected, f2(a, b)());
// verify with values directly passed
Expression<Func<Func<ushort, ushort, ushort>>> e3 =
Expression.Lambda<Func<Func<ushort, ushort, ushort>>>(
Expression.Invoke(
Expression.Lambda<Func<Func<ushort, ushort, ushort>>>(
Expression.Lambda<Func<ushort, ushort, ushort>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>()),
Enumerable.Empty<Expression>()),
Enumerable.Empty<ParameterExpression>());
Func<ushort, ushort, ushort> f3 = e3.Compile(useInterpreter)();
Assert.Equal(expected, f3(a, b));
// verify as a function generator
Expression<Func<Func<ushort, ushort, ushort>>> e4 =
Expression.Lambda<Func<Func<ushort, ushort, ushort>>>(
Expression.Lambda<Func<ushort, ushort, ushort>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p0, p1 }),
Enumerable.Empty<ParameterExpression>());
Func<Func<ushort, ushort, ushort>> f4 = e4.Compile(useInterpreter);
Assert.Equal(expected, f4()(a, b));
// verify with currying
Expression<Func<ushort, Func<ushort, ushort>>> e5 =
Expression.Lambda<Func<ushort, Func<ushort, ushort>>>(
Expression.Lambda<Func<ushort, ushort>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 });
Func<ushort, Func<ushort, ushort>> f5 = e5.Compile(useInterpreter);
Assert.Equal(expected, f5(a)(b));
// verify with one parameter
Expression<Func<Func<ushort, ushort>>> e6 =
Expression.Lambda<Func<Func<ushort, ushort>>>(
Expression.Invoke(
Expression.Lambda<Func<ushort, Func<ushort, ushort>>>(
Expression.Lambda<Func<ushort, ushort>>(
Expression.Multiply(p0, p1),
new ParameterExpression[] { p1 }),
new ParameterExpression[] { p0 }),
new Expression[] { Expression.Constant(a, typeof(ushort)) }),
Enumerable.Empty<ParameterExpression>());
Func<ushort, ushort> f6 = e6.Compile(useInterpreter)();
Assert.Equal(expected, f6(b));
}
#endregion
#endregion
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/TypeSystem/ArrayMethod.Runtime.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using Internal.Runtime.CompilerServices;
namespace Internal.TypeSystem
{
public partial class ArrayMethod : MethodDesc
{
public override MethodNameAndSignature NameAndSignature
{
get
{
// TODO Eventually implement via working with a RuntimeMethod that refers to the actual implementation.
// https://github.com/dotnet/corert/issues/3772
throw new NotImplementedException();
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using Internal.Runtime.CompilerServices;
namespace Internal.TypeSystem
{
public partial class ArrayMethod : MethodDesc
{
public override MethodNameAndSignature NameAndSignature
{
get
{
// TODO Eventually implement via working with a RuntimeMethod that refers to the actual implementation.
// https://github.com/dotnet/corert/issues/3772
throw new NotImplementedException();
}
}
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Private.CoreLib/src/System/Environment.SunOS.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.InteropServices;
namespace System
{
public static partial class Environment
{
public static long WorkingSet =>
(long)(Interop.procfs.TryReadProcessStatusInfo(ProcessId, out Interop.procfs.ProcessStatusInfo status) ? status.ResidentSetSize : 0);
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.InteropServices;
namespace System
{
public static partial class Environment
{
public static long WorkingSet =>
(long)(Interop.procfs.TryReadProcessStatusInfo(ProcessId, out Interop.procfs.ProcessStatusInfo status) ? status.ResidentSetSize : 0);
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Speech/src/Internal/SrgsCompiler/SRGSCompiler.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Speech.Internal.SrgsParser;
using System.Speech.Recognition.SrgsGrammar;
using System.Text;
using System.Xml;
namespace System.Speech.Internal.SrgsCompiler
{
internal static class SrgsCompiler
{
#region Internal Methods
/// <summary>
/// Loads the SRGS XML grammar and produces the binary grammar format.
/// </summary>
/// <param name="xmlReaders">Source SRGS XML streams</param>
/// <param name="filename">filename to compile to</param>
/// <param name="stream">stream to compile to</param>
/// <param name="fOutputCfg">Compile for CFG or DLL</param>
/// <param name="originalUri">in xmlReader.Count == 1, name of the original file</param>
/// <param name="referencedAssemblies">List of referenced assemblies</param>
/// <param name="keyFile">Strong name</param>
internal static void CompileStream(XmlReader[] xmlReaders, string filename, Stream stream, bool fOutputCfg, Uri originalUri, string[] referencedAssemblies, string keyFile)
{
// raft of files to compiler is only available for class library
System.Diagnostics.Debug.Assert(!fOutputCfg || xmlReaders.Length == 1);
int cReaders = xmlReaders.Length;
List<CustomGrammar.CfgResource> cfgResources = new();
CustomGrammar cgCombined = new();
for (int iReader = 0; iReader < cReaders; iReader++)
{
// Set the current directory to the location where is the grammar
string srgsPath = null;
Uri uri = originalUri;
if (uri == null)
{
if (xmlReaders[iReader].BaseURI != null && xmlReaders[iReader].BaseURI.Length > 0)
{
uri = new Uri(xmlReaders[iReader].BaseURI);
}
}
if (uri != null && (!uri.IsAbsoluteUri || uri.IsFile))
{
srgsPath = Path.GetDirectoryName(uri.IsAbsoluteUri ? uri.AbsolutePath : uri.OriginalString);
}
CultureInfo culture;
StringBuilder innerCode = new();
ISrgsParser srgsParser = new XmlParser(xmlReaders[iReader], uri);
object cg = CompileStream(iReader + 1, srgsParser, srgsPath, filename, stream, fOutputCfg, innerCode, cfgResources, out culture, referencedAssemblies, keyFile);
if (!fOutputCfg)
{
cgCombined.Combine((CustomGrammar)cg, innerCode.ToString());
}
}
// Create the DLL if this needs to be done
if (!fOutputCfg)
{
throw new PlatformNotSupportedException();
}
}
/// <summary>
/// Produces the binary grammar format.
/// </summary>
/// <param name="srgsGrammar">Source SRGS XML streams</param>
/// <param name="filename">filename to compile to</param>
/// <param name="stream">stream to compile to</param>
/// <param name="fOutputCfg">Compile for CFG or DLL</param>
/// <param name="referencedAssemblies">List of referenced assemblies</param>
/// <param name="keyFile">Strong name</param>
internal static void CompileStream(SrgsDocument srgsGrammar, string filename, Stream stream, bool fOutputCfg, string[] referencedAssemblies, string keyFile)
{
ISrgsParser srgsParser = new SrgsDocumentParser(srgsGrammar.Grammar);
List<CustomGrammar.CfgResource> cfgResources = new();
StringBuilder innerCode = new();
CultureInfo culture;
// Validate the grammar before compiling it. Set the tag-format and sapi flags too.
srgsGrammar.Grammar.Validate();
object cg = CompileStream(1, srgsParser, null, filename, stream, fOutputCfg, innerCode, cfgResources, out culture, referencedAssemblies, keyFile);
// Create the DLL if this needs to be done
if (!fOutputCfg)
{
throw new PlatformNotSupportedException();
}
}
#endregion
private static object CompileStream(int iCfg, ISrgsParser srgsParser, string srgsPath, string filename, Stream stream, bool fOutputCfg, StringBuilder innerCode, object cfgResources, out CultureInfo culture, string[] referencedAssemblies, string keyFile)
{
Backend backend = new();
CustomGrammar cg = new();
SrgsElementCompilerFactory elementFactory = new(backend, cg);
srgsParser.ElementFactory = elementFactory;
srgsParser.Parse();
// Optimize in-memory graph representation of the grammar.
backend.Optimize();
culture = backend.LangId == 0x540A ? new CultureInfo("es-us") : new CultureInfo(backend.LangId);
// A grammar may contains references to other files in codebehind.
// Set the current directory to the location where is the grammar
if (cg._codebehind.Count > 0 && !string.IsNullOrEmpty(srgsPath))
{
for (int i = 0; i < cg._codebehind.Count; i++)
{
if (!File.Exists(cg._codebehind[i]))
{
cg._codebehind[i] = srgsPath + "\\" + cg._codebehind[i];
}
}
}
// Add the referenced assemblies
if (referencedAssemblies != null)
{
foreach (string assembly in referencedAssemblies)
{
cg._assemblyReferences.Add(assembly);
}
}
// Assign the key file
cg._keyFile = keyFile;
// Assign the Scripts to the backend
backend.ScriptRefs = cg._scriptRefs;
// If the target is a dll, then create first the CFG and stuff it as an embedded resource
if (!fOutputCfg)
{
throw new PlatformNotSupportedException();
}
else
{
//if semantic processing for a rule is defined, a script needs to be defined
if (cg._scriptRefs.Count > 0 && !cg.HasScript)
{
XmlParser.ThrowSrgsException(SRID.NoScriptsForRules);
}
// Creates a CFG with IL embedded
CreateAssembly(backend, cg);
// Save binary grammar to dest
if (!string.IsNullOrEmpty(filename))
{
// Create a stream if a filename was given
stream = new FileStream(filename, FileMode.Create, FileAccess.Write);
}
try
{
using (StreamMarshaler streamHelper = new(stream))
{
backend.Commit(streamHelper);
}
}
finally
{
if (!string.IsNullOrEmpty(filename))
{
stream.Close();
}
}
}
return cg;
}
/// <summary>
/// Generate the assembly code for a back. The scripts are defined in custom
/// grammars.
/// </summary>
private static void CreateAssembly(Backend backend, CustomGrammar cg)
{
if (cg.HasScript)
{
throw new PlatformNotSupportedException();
}
}
}
internal enum RuleScope
{
PublicRule, PrivateRule
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Speech.Internal.SrgsParser;
using System.Speech.Recognition.SrgsGrammar;
using System.Text;
using System.Xml;
namespace System.Speech.Internal.SrgsCompiler
{
internal static class SrgsCompiler
{
#region Internal Methods
/// <summary>
/// Loads the SRGS XML grammar and produces the binary grammar format.
/// </summary>
/// <param name="xmlReaders">Source SRGS XML streams</param>
/// <param name="filename">filename to compile to</param>
/// <param name="stream">stream to compile to</param>
/// <param name="fOutputCfg">Compile for CFG or DLL</param>
/// <param name="originalUri">in xmlReader.Count == 1, name of the original file</param>
/// <param name="referencedAssemblies">List of referenced assemblies</param>
/// <param name="keyFile">Strong name</param>
internal static void CompileStream(XmlReader[] xmlReaders, string filename, Stream stream, bool fOutputCfg, Uri originalUri, string[] referencedAssemblies, string keyFile)
{
// raft of files to compiler is only available for class library
System.Diagnostics.Debug.Assert(!fOutputCfg || xmlReaders.Length == 1);
int cReaders = xmlReaders.Length;
List<CustomGrammar.CfgResource> cfgResources = new();
CustomGrammar cgCombined = new();
for (int iReader = 0; iReader < cReaders; iReader++)
{
// Set the current directory to the location where is the grammar
string srgsPath = null;
Uri uri = originalUri;
if (uri == null)
{
if (xmlReaders[iReader].BaseURI != null && xmlReaders[iReader].BaseURI.Length > 0)
{
uri = new Uri(xmlReaders[iReader].BaseURI);
}
}
if (uri != null && (!uri.IsAbsoluteUri || uri.IsFile))
{
srgsPath = Path.GetDirectoryName(uri.IsAbsoluteUri ? uri.AbsolutePath : uri.OriginalString);
}
CultureInfo culture;
StringBuilder innerCode = new();
ISrgsParser srgsParser = new XmlParser(xmlReaders[iReader], uri);
object cg = CompileStream(iReader + 1, srgsParser, srgsPath, filename, stream, fOutputCfg, innerCode, cfgResources, out culture, referencedAssemblies, keyFile);
if (!fOutputCfg)
{
cgCombined.Combine((CustomGrammar)cg, innerCode.ToString());
}
}
// Create the DLL if this needs to be done
if (!fOutputCfg)
{
throw new PlatformNotSupportedException();
}
}
/// <summary>
/// Produces the binary grammar format.
/// </summary>
/// <param name="srgsGrammar">Source SRGS XML streams</param>
/// <param name="filename">filename to compile to</param>
/// <param name="stream">stream to compile to</param>
/// <param name="fOutputCfg">Compile for CFG or DLL</param>
/// <param name="referencedAssemblies">List of referenced assemblies</param>
/// <param name="keyFile">Strong name</param>
internal static void CompileStream(SrgsDocument srgsGrammar, string filename, Stream stream, bool fOutputCfg, string[] referencedAssemblies, string keyFile)
{
ISrgsParser srgsParser = new SrgsDocumentParser(srgsGrammar.Grammar);
List<CustomGrammar.CfgResource> cfgResources = new();
StringBuilder innerCode = new();
CultureInfo culture;
// Validate the grammar before compiling it. Set the tag-format and sapi flags too.
srgsGrammar.Grammar.Validate();
object cg = CompileStream(1, srgsParser, null, filename, stream, fOutputCfg, innerCode, cfgResources, out culture, referencedAssemblies, keyFile);
// Create the DLL if this needs to be done
if (!fOutputCfg)
{
throw new PlatformNotSupportedException();
}
}
#endregion
private static object CompileStream(int iCfg, ISrgsParser srgsParser, string srgsPath, string filename, Stream stream, bool fOutputCfg, StringBuilder innerCode, object cfgResources, out CultureInfo culture, string[] referencedAssemblies, string keyFile)
{
Backend backend = new();
CustomGrammar cg = new();
SrgsElementCompilerFactory elementFactory = new(backend, cg);
srgsParser.ElementFactory = elementFactory;
srgsParser.Parse();
// Optimize in-memory graph representation of the grammar.
backend.Optimize();
culture = backend.LangId == 0x540A ? new CultureInfo("es-us") : new CultureInfo(backend.LangId);
// A grammar may contains references to other files in codebehind.
// Set the current directory to the location where is the grammar
if (cg._codebehind.Count > 0 && !string.IsNullOrEmpty(srgsPath))
{
for (int i = 0; i < cg._codebehind.Count; i++)
{
if (!File.Exists(cg._codebehind[i]))
{
cg._codebehind[i] = srgsPath + "\\" + cg._codebehind[i];
}
}
}
// Add the referenced assemblies
if (referencedAssemblies != null)
{
foreach (string assembly in referencedAssemblies)
{
cg._assemblyReferences.Add(assembly);
}
}
// Assign the key file
cg._keyFile = keyFile;
// Assign the Scripts to the backend
backend.ScriptRefs = cg._scriptRefs;
// If the target is a dll, then create first the CFG and stuff it as an embedded resource
if (!fOutputCfg)
{
throw new PlatformNotSupportedException();
}
else
{
//if semantic processing for a rule is defined, a script needs to be defined
if (cg._scriptRefs.Count > 0 && !cg.HasScript)
{
XmlParser.ThrowSrgsException(SRID.NoScriptsForRules);
}
// Creates a CFG with IL embedded
CreateAssembly(backend, cg);
// Save binary grammar to dest
if (!string.IsNullOrEmpty(filename))
{
// Create a stream if a filename was given
stream = new FileStream(filename, FileMode.Create, FileAccess.Write);
}
try
{
using (StreamMarshaler streamHelper = new(stream))
{
backend.Commit(streamHelper);
}
}
finally
{
if (!string.IsNullOrEmpty(filename))
{
stream.Close();
}
}
}
return cg;
}
/// <summary>
/// Generate the assembly code for a back. The scripts are defined in custom
/// grammars.
/// </summary>
private static void CreateAssembly(Backend backend, CustomGrammar cg)
{
if (cg.HasScript)
{
throw new PlatformNotSupportedException();
}
}
}
internal enum RuleScope
{
PublicRule, PrivateRule
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/coreclr/scripts/exploratory.md
|
# Documentation of Exploratory tools Antigen and Fuzzlyn
[Antigen](https://github.com/kunalspathak/antigen) and [Fuzzlyn](https://github.com/jakobbotsch/Fuzzlyn) are exploratory fuzzing tools used to test the JIT compiler.
## Overview
The basics of both tools are the same: they generate random programs using Roslyn and execute them with `corerun.exe` in a baseline and a test mode.
Typically, baseline uses the JIT with minimum optimizations enabled while the test mode has optimizations enabled.
Antigen also sets various `COMPlus_*` variables in its test mode to turn on different stress modes or turn on/off different optimizations.
The fuzzers detect issues by checking for assertion failures and by comparing results between the baseline and test modes.
For more information, see the respectives repos.
## Pipeline
Both Antigen and Fuzzlyn run on a schedule using the CI pipeline. They can also be triggered on PRs with `/azp run Antigen` and `/azp run Fuzzlyn` respectively.
The pipeline produces a summary of issues found under the "Extensions" tab when looking at the pipeline results.
## Getting test examples from Antigen runs
For Antigen runs, the summary will show the assertion errors that were hit.
Individual test examples are available as artifacts that can be downloaded for each OS/arch.
The issues will be `.cs` files that will contain the program's output, environment variables that are needed to reproduce the issue.
Since there can be several issues, the pipeline will just upload at most 5 issues.
## Getting test examples from Fuzzlyn runs
The Fuzzlyn pipeline will automatically reduce silent bad codegen examples that are found and include them as source code in the summary that can be viewed under "Extensions".
The pipeline does not currently reduce assertion error examples automatically and instead only displays the seeds for the programs that failed.
To reduce these examples manually, clone Fuzzlyn and run it as follows (adapting for Linux platforms as necessary):
```powershell
Fuzzlyn.exe --host <path to corerun.exe under test (typically a checked build)> --reduce --seed <seed from the summary>
```
This will take a long time if the example being reduced is one that brings down the host process on every run (e.g. for assertion failures).
When completed, the reduced example will be output on stdout.
### Pipeline details
1. `eng/pipeline/coreclr/exploratory.yml` : This is the main pipeline which will perform Coreclr/libraries build and then further trigger `jit-exploratory-job.yml` pipeline.
It uses the name of the pipeline being run to determine whether Antigen or Fuzzlyn is being used.
1. `eng/pipeline/coreclr/templates/jit-exploratory-job.yml` : This pipeline will download all the Coreclr/libraries artifacts and create `CORE_ROOT` folder. It further triggers `jit-run-exploratory-job.yml` pipeline.
1. `eng/pipeline/coreclr/templates/jit-run-exploratory-job.yml` : This pipeline will perform the actual run in 3 steps:
* `src/coreclr/scripts/fuzzer_setup.py`: This script will clone the Antigen/Fuzzlyn repo, build and prepare the payloads to be sent for testing.
* `src/coreclr/scripts/<antigen or fuzzlyn>_run.py`: This script will execute the tool and upload back the issues.
* `src/coreclr/scripts/<antigen or fuzzlyn>_summarize.py`: In addition to uploading the issues, this script will also summarize the issues that were found so the developer can quickly take a look at them and decide how to proceed.
This script is responsible for printing the markdown summary that uses Azure devops features to show up under the "Extensions" tab.
Furthermore, it returns an error code if any issues were found.
1. `src/coreclr/scripts/exploratory.proj`: This proj file is the one that creates the helix jobs. Currently, this file configures to run Antigen/Fuzzlyn on 4 partitions.
Thus, if Antigen can generate and test 1000 test cases on 1 machine, with current setup, the pipeline will be able to test 4000 test cases.
|
# Documentation of Exploratory tools Antigen and Fuzzlyn
[Antigen](https://github.com/kunalspathak/antigen) and [Fuzzlyn](https://github.com/jakobbotsch/Fuzzlyn) are exploratory fuzzing tools used to test the JIT compiler.
## Overview
The basics of both tools are the same: they generate random programs using Roslyn and execute them with `corerun.exe` in a baseline and a test mode.
Typically, baseline uses the JIT with minimum optimizations enabled while the test mode has optimizations enabled.
Antigen also sets various `COMPlus_*` variables in its test mode to turn on different stress modes or turn on/off different optimizations.
The fuzzers detect issues by checking for assertion failures and by comparing results between the baseline and test modes.
For more information, see the respectives repos.
## Pipeline
Both Antigen and Fuzzlyn run on a schedule using the CI pipeline. They can also be triggered on PRs with `/azp run Antigen` and `/azp run Fuzzlyn` respectively.
The pipeline produces a summary of issues found under the "Extensions" tab when looking at the pipeline results.
## Getting test examples from Antigen runs
For Antigen runs, the summary will show the assertion errors that were hit.
Individual test examples are available as artifacts that can be downloaded for each OS/arch.
The issues will be `.cs` files that will contain the program's output, environment variables that are needed to reproduce the issue.
Since there can be several issues, the pipeline will just upload at most 5 issues.
## Getting test examples from Fuzzlyn runs
The Fuzzlyn pipeline will automatically reduce silent bad codegen examples that are found and include them as source code in the summary that can be viewed under "Extensions".
The pipeline does not currently reduce assertion error examples automatically and instead only displays the seeds for the programs that failed.
To reduce these examples manually, clone Fuzzlyn and run it as follows (adapting for Linux platforms as necessary):
```powershell
Fuzzlyn.exe --host <path to corerun.exe under test (typically a checked build)> --reduce --seed <seed from the summary>
```
This will take a long time if the example being reduced is one that brings down the host process on every run (e.g. for assertion failures).
When completed, the reduced example will be output on stdout.
### Pipeline details
1. `eng/pipeline/coreclr/exploratory.yml` : This is the main pipeline which will perform Coreclr/libraries build and then further trigger `jit-exploratory-job.yml` pipeline.
It uses the name of the pipeline being run to determine whether Antigen or Fuzzlyn is being used.
1. `eng/pipeline/coreclr/templates/jit-exploratory-job.yml` : This pipeline will download all the Coreclr/libraries artifacts and create `CORE_ROOT` folder. It further triggers `jit-run-exploratory-job.yml` pipeline.
1. `eng/pipeline/coreclr/templates/jit-run-exploratory-job.yml` : This pipeline will perform the actual run in 3 steps:
* `src/coreclr/scripts/fuzzer_setup.py`: This script will clone the Antigen/Fuzzlyn repo, build and prepare the payloads to be sent for testing.
* `src/coreclr/scripts/<antigen or fuzzlyn>_run.py`: This script will execute the tool and upload back the issues.
* `src/coreclr/scripts/<antigen or fuzzlyn>_summarize.py`: In addition to uploading the issues, this script will also summarize the issues that were found so the developer can quickly take a look at them and decide how to proceed.
This script is responsible for printing the markdown summary that uses Azure devops features to show up under the "Extensions" tab.
Furthermore, it returns an error code if any issues were found.
1. `src/coreclr/scripts/exploratory.proj`: This proj file is the one that creates the helix jobs. Currently, this file configures to run Antigen/Fuzzlyn on 4 partitions.
Thus, if Antigen can generate and test 1000 test cases on 1 machine, with current setup, the pipeline will be able to test 4000 test cases.
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/tests/JIT/Methodical/tailcall/reference_i.il
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
.assembly extern mscorlib { }
.assembly extern System.Console
{
.publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )
.ver 4:0:0:0
}
.assembly extern xunit.core {}
.assembly reference_i { }
.method public static class System.String
rems(int32& n,
int32& m) il managed
{
// Code size 93 (0x5d)
.maxstack 8
.locals (int32[] V_0)
IL_0000: ldarg.1
IL_0001: ldind.i4
IL_0002: ldc.i4.1
IL_0003: bne.un.s IL_0007
IL_0005: ldnull
IL_0006: ret
IL_0007: ldc.i4.1
IL_0008: newarr int32
IL_000d: stloc.0
IL_000e: ldloc.0
IL_000f: ldc.i4.0
IL_0010: ldarg.1
IL_0011: ldind.i4
IL_0012: ldc.i4.1
IL_0013: sub
IL_0014: stelem.i4
IL_0015: ldarg.0
IL_0016: ldind.i4
IL_0017: ldarg.1
IL_0018: ldind.i4
IL_0019: rem
IL_001a: brtrue.s IL_0047
IL_001c: ldarg.0
IL_001d: ldloc.0
IL_001e: ldc.i4.0
IL_001f: ldelema int32
IL_0024: call class System.String rems(int32&,
int32&)
IL_0029: ldstr " "
IL_002e: call class System.String [mscorlib]System.String::Concat(class System.String,
class System.String)
IL_0033: ldarg.1
IL_0034: call instance class System.String [mscorlib]System.Int32::ToString()
IL_0039: ldftn class System.String [mscorlib]System.String::Concat(class System.String,
class System.String)
IL_003f: tail.
IL_0041: calli class System.String(class System.String,class System.String)
IL_0046: ret
IL_0047: ldarg.0
IL_0048: ldloc.0
IL_0049: ldc.i4.0
IL_004a: ldelema int32
IL_004f: ldftn class System.String rems(int32&,
int32&)
IL_0055: tail.
IL_0057: calli class System.String(int32&,int32&)
IL_005c: ret
} // end of global method rems
.class public auto ansi beforefieldinit Test_reference_i extends [mscorlib]System.Object
{
.method public static int32 main() il managed
{
.custom instance void [xunit.core]Xunit.FactAttribute::.ctor() = (
01 00 00 00
)
.entrypoint
// Code size 66 (0x42)
.maxstack 2
.locals (int32 V_0,
int32 V_1)
IL_0000: ldc.i4.2
IL_0001: stloc.0
IL_0002: br.s IL_0008
IL_0004: ldloc.0
IL_0005: ldc.i4.1
IL_0006: add
IL_0007: stloc.0
IL_0008: ldloc.0
IL_0009: ldc.i4 0x3e8
IL_000e: bge.s IL_0037
IL_0010: ldloc.0
IL_0011: ldc.i4.1
IL_0012: sub
IL_0013: stloc.1
IL_0014: ldloca.s V_0
IL_0016: ldloca.s V_1
IL_0018: call class System.String rems(int32&,
int32&)
IL_001d: brtrue.s IL_0035
IL_001f: ldloca.s V_0
IL_0021: call instance class System.String [mscorlib]System.Int32::ToString()
IL_0026: call void [System.Console]System.Console::Write(class System.String)
IL_002b: ldstr " "
IL_0030: call void [System.Console]System.Console::Write(class System.String)
IL_0035: br.s IL_0004
IL_0037: call void [System.Console]System.Console::WriteLine()
IL_003c: ldc.i4 0x64
IL_0041: ret
} // end of method main
.method public hidebysig specialname rtspecialname
instance void .ctor() il managed
{
.maxstack 8
IL_0000: ldarg.0
IL_0001: call instance void [mscorlib]System.Object::.ctor()
IL_0006: ret
}
}
//*********** DISASSEMBLY COMPLETE ***********************
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
.assembly extern mscorlib { }
.assembly extern System.Console
{
.publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )
.ver 4:0:0:0
}
.assembly extern xunit.core {}
.assembly reference_i { }
.method public static class System.String
rems(int32& n,
int32& m) il managed
{
// Code size 93 (0x5d)
.maxstack 8
.locals (int32[] V_0)
IL_0000: ldarg.1
IL_0001: ldind.i4
IL_0002: ldc.i4.1
IL_0003: bne.un.s IL_0007
IL_0005: ldnull
IL_0006: ret
IL_0007: ldc.i4.1
IL_0008: newarr int32
IL_000d: stloc.0
IL_000e: ldloc.0
IL_000f: ldc.i4.0
IL_0010: ldarg.1
IL_0011: ldind.i4
IL_0012: ldc.i4.1
IL_0013: sub
IL_0014: stelem.i4
IL_0015: ldarg.0
IL_0016: ldind.i4
IL_0017: ldarg.1
IL_0018: ldind.i4
IL_0019: rem
IL_001a: brtrue.s IL_0047
IL_001c: ldarg.0
IL_001d: ldloc.0
IL_001e: ldc.i4.0
IL_001f: ldelema int32
IL_0024: call class System.String rems(int32&,
int32&)
IL_0029: ldstr " "
IL_002e: call class System.String [mscorlib]System.String::Concat(class System.String,
class System.String)
IL_0033: ldarg.1
IL_0034: call instance class System.String [mscorlib]System.Int32::ToString()
IL_0039: ldftn class System.String [mscorlib]System.String::Concat(class System.String,
class System.String)
IL_003f: tail.
IL_0041: calli class System.String(class System.String,class System.String)
IL_0046: ret
IL_0047: ldarg.0
IL_0048: ldloc.0
IL_0049: ldc.i4.0
IL_004a: ldelema int32
IL_004f: ldftn class System.String rems(int32&,
int32&)
IL_0055: tail.
IL_0057: calli class System.String(int32&,int32&)
IL_005c: ret
} // end of global method rems
.class public auto ansi beforefieldinit Test_reference_i extends [mscorlib]System.Object
{
.method public static int32 main() il managed
{
.custom instance void [xunit.core]Xunit.FactAttribute::.ctor() = (
01 00 00 00
)
.entrypoint
// Code size 66 (0x42)
.maxstack 2
.locals (int32 V_0,
int32 V_1)
IL_0000: ldc.i4.2
IL_0001: stloc.0
IL_0002: br.s IL_0008
IL_0004: ldloc.0
IL_0005: ldc.i4.1
IL_0006: add
IL_0007: stloc.0
IL_0008: ldloc.0
IL_0009: ldc.i4 0x3e8
IL_000e: bge.s IL_0037
IL_0010: ldloc.0
IL_0011: ldc.i4.1
IL_0012: sub
IL_0013: stloc.1
IL_0014: ldloca.s V_0
IL_0016: ldloca.s V_1
IL_0018: call class System.String rems(int32&,
int32&)
IL_001d: brtrue.s IL_0035
IL_001f: ldloca.s V_0
IL_0021: call instance class System.String [mscorlib]System.Int32::ToString()
IL_0026: call void [System.Console]System.Console::Write(class System.String)
IL_002b: ldstr " "
IL_0030: call void [System.Console]System.Console::Write(class System.String)
IL_0035: br.s IL_0004
IL_0037: call void [System.Console]System.Console::WriteLine()
IL_003c: ldc.i4 0x64
IL_0041: ret
} // end of method main
.method public hidebysig specialname rtspecialname
instance void .ctor() il managed
{
.maxstack 8
IL_0000: ldarg.0
IL_0001: call instance void [mscorlib]System.Object::.ctor()
IL_0006: ret
}
}
//*********** DISASSEMBLY COMPLETE ***********************
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/tests/JIT/Methodical/NaN/arithm64_d.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
</PropertyGroup>
<PropertyGroup>
<DebugType>full</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="arithm64.cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
</PropertyGroup>
<PropertyGroup>
<DebugType>full</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="arithm64.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/tests/JIT/HardwareIntrinsics/X86/Sse1/ReciprocalScalar_r.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<PropertyGroup>
<DebugType>Embedded</DebugType>
<Optimize />
</PropertyGroup>
<ItemGroup>
<Compile Include="ReciprocalScalar.cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<PropertyGroup>
<DebugType>Embedded</DebugType>
<Optimize />
</PropertyGroup>
<ItemGroup>
<Compile Include="ReciprocalScalar.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Private.Xml/tests/Xslt/TestFiles/TestData/xsltc/baseline/cnt2.txt
|
<?xml version="1.0" encoding="utf-8"?>Hello, world!
|
<?xml version="1.0" encoding="utf-8"?>Hello, world!
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/native/eventpipe/ep-session-provider.c
|
#include "ep-rt-config.h"
#ifdef ENABLE_PERFTRACING
#if !defined(EP_INCLUDE_SOURCE_FILES) || defined(EP_FORCE_INCLUDE_SOURCE_FILES)
#define EP_IMPL_SESSION_PROVIDER_GETTER_SETTER
#include "ep-session-provider.h"
#include "ep-rt.h"
/*
* Forward declares of all static functions.
*/
static
void
session_provider_free_func (void *session_provider);
/*
* EventPipeSessionProvider.
*/
static
void
session_provider_free_func (void *session_provider)
{
ep_session_provider_free ((EventPipeSessionProvider *)session_provider);
}
EventPipeSessionProvider *
ep_session_provider_alloc (
const ep_char8_t *provider_name,
uint64_t keywords,
EventPipeEventLevel logging_level,
const ep_char8_t *filter_data)
{
EventPipeSessionProvider *instance = ep_rt_object_alloc (EventPipeSessionProvider);
ep_raise_error_if_nok (instance != NULL);
if (provider_name) {
instance->provider_name = ep_rt_utf8_string_dup (provider_name);
ep_raise_error_if_nok (instance->provider_name != NULL);
}
if (filter_data) {
instance->filter_data = ep_rt_utf8_string_dup (filter_data);
ep_raise_error_if_nok (instance->filter_data != NULL);
}
instance->keywords = keywords;
instance->logging_level = logging_level;
ep_on_exit:
return instance;
ep_on_error:
ep_session_provider_free (instance);
instance = NULL;
ep_exit_error_handler ();
}
void
ep_session_provider_free (EventPipeSessionProvider * session_provider)
{
ep_return_void_if_nok (session_provider != NULL);
ep_rt_utf8_string_free (session_provider->filter_data);
ep_rt_utf8_string_free (session_provider->provider_name);
ep_rt_object_free (session_provider);
}
/*
* EventPipeSessionProviderList.
*/
EventPipeSessionProviderList *
ep_session_provider_list_alloc (
const EventPipeProviderConfiguration *configs,
uint32_t configs_len)
{
ep_return_null_if_nok ((configs_len == 0) || (configs_len > 0 && configs != NULL));
EventPipeSessionProviderList *instance = ep_rt_object_alloc (EventPipeSessionProviderList);
ep_raise_error_if_nok (instance != NULL);
ep_rt_session_provider_list_alloc (&instance->providers);
ep_raise_error_if_nok (ep_rt_session_provider_list_is_valid (&instance->providers));
instance->catch_all_provider = NULL;
for (uint32_t i = 0; i < configs_len; ++i) {
const EventPipeProviderConfiguration *config = &configs [i];
EP_ASSERT (config != NULL);
// Enable all events if the provider name == '*', all keywords are on and the requested level == verbose.
if ((ep_rt_utf8_string_compare(ep_provider_get_wildcard_name_utf8 (), ep_provider_config_get_provider_name (config)) == 0) &&
(ep_provider_config_get_keywords (config) == 0xFFFFFFFFFFFFFFFF) &&
((ep_provider_config_get_logging_level (config) == EP_EVENT_LEVEL_VERBOSE) && (instance->catch_all_provider == NULL))) {
instance->catch_all_provider = ep_session_provider_alloc (NULL, 0xFFFFFFFFFFFFFFFF, EP_EVENT_LEVEL_VERBOSE, NULL );
ep_raise_error_if_nok (instance->catch_all_provider != NULL);
}
else {
EventPipeSessionProvider * session_provider = ep_session_provider_alloc (
ep_provider_config_get_provider_name (config),
ep_provider_config_get_keywords (config),
ep_provider_config_get_logging_level (config),
ep_provider_config_get_filter_data (config));
ep_raise_error_if_nok (ep_rt_session_provider_list_append (&instance->providers, session_provider));
}
}
ep_on_exit:
return instance;
ep_on_error:
ep_session_provider_list_free (instance);
instance = NULL;
ep_exit_error_handler ();
}
void
ep_session_provider_list_free (EventPipeSessionProviderList *session_provider_list)
{
ep_return_void_if_nok (session_provider_list != NULL);
ep_rt_session_provider_list_free (&session_provider_list->providers, session_provider_free_func);
ep_session_provider_free (session_provider_list->catch_all_provider);
ep_rt_object_free (session_provider_list);
}
void
ep_session_provider_list_clear (EventPipeSessionProviderList *session_provider_list)
{
EP_ASSERT (session_provider_list != NULL);
ep_rt_session_provider_list_clear (&session_provider_list->providers, session_provider_free_func);
}
bool
ep_session_provider_list_is_empty (const EventPipeSessionProviderList *session_provider_list)
{
EP_ASSERT (session_provider_list != NULL);
return (ep_rt_session_provider_list_is_empty (&session_provider_list->providers) && session_provider_list->catch_all_provider == NULL);
}
bool
ep_session_provider_list_add_session_provider (
EventPipeSessionProviderList *session_provider_list,
EventPipeSessionProvider *session_provider)
{
EP_ASSERT (session_provider_list != NULL);
EP_ASSERT (session_provider != NULL);
return ep_rt_session_provider_list_append (&session_provider_list->providers, session_provider);
}
#endif /* !defined(EP_INCLUDE_SOURCE_FILES) || defined(EP_FORCE_INCLUDE_SOURCE_FILES) */
#endif /* ENABLE_PERFTRACING */
#ifndef EP_INCLUDE_SOURCE_FILES
extern const char quiet_linker_empty_file_warning_eventpipe_session_provider;
const char quiet_linker_empty_file_warning_eventpipe_session_provider = 0;
#endif
|
#include "ep-rt-config.h"
#ifdef ENABLE_PERFTRACING
#if !defined(EP_INCLUDE_SOURCE_FILES) || defined(EP_FORCE_INCLUDE_SOURCE_FILES)
#define EP_IMPL_SESSION_PROVIDER_GETTER_SETTER
#include "ep-session-provider.h"
#include "ep-rt.h"
/*
* Forward declares of all static functions.
*/
static
void
session_provider_free_func (void *session_provider);
/*
* EventPipeSessionProvider.
*/
static
void
session_provider_free_func (void *session_provider)
{
ep_session_provider_free ((EventPipeSessionProvider *)session_provider);
}
EventPipeSessionProvider *
ep_session_provider_alloc (
const ep_char8_t *provider_name,
uint64_t keywords,
EventPipeEventLevel logging_level,
const ep_char8_t *filter_data)
{
EventPipeSessionProvider *instance = ep_rt_object_alloc (EventPipeSessionProvider);
ep_raise_error_if_nok (instance != NULL);
if (provider_name) {
instance->provider_name = ep_rt_utf8_string_dup (provider_name);
ep_raise_error_if_nok (instance->provider_name != NULL);
}
if (filter_data) {
instance->filter_data = ep_rt_utf8_string_dup (filter_data);
ep_raise_error_if_nok (instance->filter_data != NULL);
}
instance->keywords = keywords;
instance->logging_level = logging_level;
ep_on_exit:
return instance;
ep_on_error:
ep_session_provider_free (instance);
instance = NULL;
ep_exit_error_handler ();
}
void
ep_session_provider_free (EventPipeSessionProvider * session_provider)
{
ep_return_void_if_nok (session_provider != NULL);
ep_rt_utf8_string_free (session_provider->filter_data);
ep_rt_utf8_string_free (session_provider->provider_name);
ep_rt_object_free (session_provider);
}
/*
* EventPipeSessionProviderList.
*/
EventPipeSessionProviderList *
ep_session_provider_list_alloc (
const EventPipeProviderConfiguration *configs,
uint32_t configs_len)
{
ep_return_null_if_nok ((configs_len == 0) || (configs_len > 0 && configs != NULL));
EventPipeSessionProviderList *instance = ep_rt_object_alloc (EventPipeSessionProviderList);
ep_raise_error_if_nok (instance != NULL);
ep_rt_session_provider_list_alloc (&instance->providers);
ep_raise_error_if_nok (ep_rt_session_provider_list_is_valid (&instance->providers));
instance->catch_all_provider = NULL;
for (uint32_t i = 0; i < configs_len; ++i) {
const EventPipeProviderConfiguration *config = &configs [i];
EP_ASSERT (config != NULL);
// Enable all events if the provider name == '*', all keywords are on and the requested level == verbose.
if ((ep_rt_utf8_string_compare(ep_provider_get_wildcard_name_utf8 (), ep_provider_config_get_provider_name (config)) == 0) &&
(ep_provider_config_get_keywords (config) == 0xFFFFFFFFFFFFFFFF) &&
((ep_provider_config_get_logging_level (config) == EP_EVENT_LEVEL_VERBOSE) && (instance->catch_all_provider == NULL))) {
instance->catch_all_provider = ep_session_provider_alloc (NULL, 0xFFFFFFFFFFFFFFFF, EP_EVENT_LEVEL_VERBOSE, NULL );
ep_raise_error_if_nok (instance->catch_all_provider != NULL);
}
else {
EventPipeSessionProvider * session_provider = ep_session_provider_alloc (
ep_provider_config_get_provider_name (config),
ep_provider_config_get_keywords (config),
ep_provider_config_get_logging_level (config),
ep_provider_config_get_filter_data (config));
ep_raise_error_if_nok (ep_rt_session_provider_list_append (&instance->providers, session_provider));
}
}
ep_on_exit:
return instance;
ep_on_error:
ep_session_provider_list_free (instance);
instance = NULL;
ep_exit_error_handler ();
}
void
ep_session_provider_list_free (EventPipeSessionProviderList *session_provider_list)
{
ep_return_void_if_nok (session_provider_list != NULL);
ep_rt_session_provider_list_free (&session_provider_list->providers, session_provider_free_func);
ep_session_provider_free (session_provider_list->catch_all_provider);
ep_rt_object_free (session_provider_list);
}
void
ep_session_provider_list_clear (EventPipeSessionProviderList *session_provider_list)
{
EP_ASSERT (session_provider_list != NULL);
ep_rt_session_provider_list_clear (&session_provider_list->providers, session_provider_free_func);
}
bool
ep_session_provider_list_is_empty (const EventPipeSessionProviderList *session_provider_list)
{
EP_ASSERT (session_provider_list != NULL);
return (ep_rt_session_provider_list_is_empty (&session_provider_list->providers) && session_provider_list->catch_all_provider == NULL);
}
bool
ep_session_provider_list_add_session_provider (
EventPipeSessionProviderList *session_provider_list,
EventPipeSessionProvider *session_provider)
{
EP_ASSERT (session_provider_list != NULL);
EP_ASSERT (session_provider != NULL);
return ep_rt_session_provider_list_append (&session_provider_list->providers, session_provider);
}
#endif /* !defined(EP_INCLUDE_SOURCE_FILES) || defined(EP_FORCE_INCLUDE_SOURCE_FILES) */
#endif /* ENABLE_PERFTRACING */
#ifndef EP_INCLUDE_SOURCE_FILES
extern const char quiet_linker_empty_file_warning_eventpipe_session_provider;
const char quiet_linker_empty_file_warning_eventpipe_session_provider = 0;
#endif
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/tests/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single_r.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<PropertyGroup>
<DebugType>Embedded</DebugType>
<Optimize />
</PropertyGroup>
<ItemGroup>
<Compile Include="ConvertScalarToVector128Single.cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<PropertyGroup>
<DebugType>Embedded</DebugType>
<Optimize />
</PropertyGroup>
<ItemGroup>
<Compile Include="ConvertScalarToVector128Single.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.CodeDom/src/System/CodeDom/CodeExpressionCollection.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
namespace System.CodeDom
{
public class CodeExpressionCollection : CollectionBase
{
public CodeExpressionCollection() { }
public CodeExpressionCollection(CodeExpressionCollection value)
{
AddRange(value);
}
public CodeExpressionCollection(CodeExpression[] value)
{
AddRange(value);
}
public CodeExpression this[int index]
{
get => (CodeExpression)List[index];
set => List[index] = value;
}
public int Add(CodeExpression value) => List.Add(value);
public void AddRange(CodeExpression[] value!!)
{
for (int i = 0; i < value.Length; i++)
{
Add(value[i]);
}
}
public void AddRange(CodeExpressionCollection value!!)
{
int currentCount = value.Count;
for (int i = 0; i < currentCount; i++)
{
Add(value[i]);
}
}
public bool Contains(CodeExpression value) => List.Contains(value);
public void CopyTo(CodeExpression[] array, int index) => List.CopyTo(array, index);
public int IndexOf(CodeExpression value) => List.IndexOf(value);
public void Insert(int index, CodeExpression value) => List.Insert(index, value);
public void Remove(CodeExpression value) => List.Remove(value);
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
namespace System.CodeDom
{
public class CodeExpressionCollection : CollectionBase
{
public CodeExpressionCollection() { }
public CodeExpressionCollection(CodeExpressionCollection value)
{
AddRange(value);
}
public CodeExpressionCollection(CodeExpression[] value)
{
AddRange(value);
}
public CodeExpression this[int index]
{
get => (CodeExpression)List[index];
set => List[index] = value;
}
public int Add(CodeExpression value) => List.Add(value);
public void AddRange(CodeExpression[] value!!)
{
for (int i = 0; i < value.Length; i++)
{
Add(value[i]);
}
}
public void AddRange(CodeExpressionCollection value!!)
{
int currentCount = value.Count;
for (int i = 0; i < currentCount; i++)
{
Add(value[i]);
}
}
public bool Contains(CodeExpression value) => List.Contains(value);
public void CopyTo(CodeExpression[] array, int index) => List.CopyTo(array, index);
public int IndexOf(CodeExpression value) => List.IndexOf(value);
public void Insert(int index, CodeExpression value) => List.Insert(index, value);
public void Remove(CodeExpression value) => List.Remove(value);
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Security.Cryptography/tests/DefaultECDiffieHellmanProvider.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
namespace System.Security.Cryptography.EcDiffieHellman.Tests
{
public partial class ECDiffieHellmanProvider : IECDiffieHellmanProvider
{
public ECDiffieHellman Create()
{
return ECDiffieHellman.Create();
}
public ECDiffieHellman Create(int keySize)
{
ECDiffieHellman ec = Create();
ec.KeySize = keySize;
return ec;
}
public ECDiffieHellman Create(ECCurve curve)
{
return ECDiffieHellman.Create(curve);
}
}
public partial class ECDiffieHellmanFactory
{
private static readonly IECDiffieHellmanProvider s_provider = new ECDiffieHellmanProvider();
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
namespace System.Security.Cryptography.EcDiffieHellman.Tests
{
public partial class ECDiffieHellmanProvider : IECDiffieHellmanProvider
{
public ECDiffieHellman Create()
{
return ECDiffieHellman.Create();
}
public ECDiffieHellman Create(int keySize)
{
ECDiffieHellman ec = Create();
ec.KeySize = keySize;
return ec;
}
public ECDiffieHellman Create(ECCurve curve)
{
return ECDiffieHellman.Create(curve);
}
}
public partial class ECDiffieHellmanFactory
{
private static readonly IECDiffieHellmanProvider s_provider = new ECDiffieHellmanProvider();
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/tests/Loader/classloader/TypeGeneratorTests/TypeGeneratorTest205/Generated205.ilproj
|
<Project Sdk="Microsoft.NET.Sdk.IL">
<PropertyGroup>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
<Compile Include="Generated205.il" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\TestFramework\TestFramework.csproj" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk.IL">
<PropertyGroup>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
<Compile Include="Generated205.il" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\TestFramework\TestFramework.csproj" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpAuthenticatedConnectionHandler.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Threading;
using System.Threading.Tasks;
namespace System.Net.Http
{
internal sealed class HttpAuthenticatedConnectionHandler : HttpMessageHandlerStage
{
private readonly HttpConnectionPoolManager _poolManager;
public HttpAuthenticatedConnectionHandler(HttpConnectionPoolManager poolManager)
{
_poolManager = poolManager;
}
internal override ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)
{
return _poolManager.SendAsync(request, async, doRequestAuth: true, cancellationToken);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
_poolManager.Dispose();
}
base.Dispose(disposing);
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Threading;
using System.Threading.Tasks;
namespace System.Net.Http
{
internal sealed class HttpAuthenticatedConnectionHandler : HttpMessageHandlerStage
{
private readonly HttpConnectionPoolManager _poolManager;
public HttpAuthenticatedConnectionHandler(HttpConnectionPoolManager poolManager)
{
_poolManager = poolManager;
}
internal override ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)
{
return _poolManager.SendAsync(request, async, doRequestAuth: true, cancellationToken);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
_poolManager.Dispose();
}
base.Dispose(disposing);
}
}
}
| -1 |
dotnet/runtime
| 66,364 |
Inject existing object into MEF2
|
Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
huoyaoyuan
| 2022-03-08T22:37:36Z | 2022-03-16T22:03:42Z |
e34e8dd85e7ffaaad8c884de0967cb8d845af5c6
|
6fdd29a31f50fda711eaa79bef58364ea714b3f4
|
Inject existing object into MEF2. Closes #29400.
MEF looks not actively developed today, but this feature has been long required. Is it still open for change?
The implementation is directly taken and not optimal.
A usage of this is AsmDiff in arcade.
|
./src/libraries/Common/tests/System/Diagnostics/Tracing/TestEventListener.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Threading.Tasks;
namespace System.Diagnostics.Tracing
{
/// <summary>Simple event listener than invokes a callback for each event received.</summary>
internal sealed class TestEventListener : EventListener
{
private class Settings
{
public EventLevel Level;
public EventKeywords Keywords;
}
private readonly Dictionary<string, Settings> _names = new Dictionary<string, Settings>();
private readonly Dictionary<Guid, Settings> _guids = new Dictionary<Guid, Settings>();
private readonly double? _eventCounterInterval;
private Action<EventWrittenEventArgs> _eventWritten;
private readonly List<EventSource> _eventSourceList = new List<EventSource>();
public TestEventListener(string targetSourceName, EventLevel level, double? eventCounterInterval = null)
{
_eventCounterInterval = eventCounterInterval;
AddSource(targetSourceName, level);
}
public TestEventListener(Guid targetSourceGuid, EventLevel level, double? eventCounterInterval = null)
{
_eventCounterInterval = eventCounterInterval;
AddSource(targetSourceGuid, level);
}
public void AddSource(string name, EventLevel level, EventKeywords keywords = EventKeywords.All) =>
AddSource(name, null, level, keywords);
public void AddSource(Guid guid, EventLevel level, EventKeywords keywords = EventKeywords.All) =>
AddSource(null, guid, level, keywords);
private void AddSource(string name, Guid? guid, EventLevel level, EventKeywords keywords)
{
EventSource sourceToEnable = null;
lock (_eventSourceList)
{
var settings = new Settings()
{
Level = level,
Keywords = keywords
};
if (name is not null)
_names.Add(name, settings);
if (guid.HasValue)
_guids.Add(guid.Value, settings);
foreach (EventSource source in _eventSourceList)
{
if (name == source.Name || guid == source.Guid)
{
sourceToEnable = source;
break;
}
}
}
if (sourceToEnable != null)
{
EnableEventSource(sourceToEnable, level, keywords);
}
}
public void AddActivityTracking() =>
AddSource("System.Threading.Tasks.TplEventSource", EventLevel.Informational, (EventKeywords)0x80 /* TasksFlowActivityIds */);
protected override void OnEventSourceCreated(EventSource eventSource)
{
bool shouldEnable = false;
Settings settings;
lock (_eventSourceList)
{
_eventSourceList.Add(eventSource);
shouldEnable = _names.TryGetValue(eventSource.Name, out settings) || _guids.TryGetValue(eventSource.Guid, out settings);
}
if (shouldEnable)
{
EnableEventSource(eventSource, settings.Level, settings.Keywords);
}
}
private void EnableEventSource(EventSource source, EventLevel level, EventKeywords keywords)
{
var args = new Dictionary<string, string>();
if (_eventCounterInterval != null)
{
args.Add("EventCounterIntervalSec", _eventCounterInterval.ToString());
}
EnableEvents(source, level, keywords, args);
}
public void RunWithCallback(Action<EventWrittenEventArgs> handler, Action body)
{
_eventWritten = handler;
try { body(); }
finally { _eventWritten = null; }
}
public async Task RunWithCallbackAsync(Action<EventWrittenEventArgs> handler, Func<Task> body)
{
_eventWritten = handler;
try { await body().ConfigureAwait(false); }
finally { _eventWritten = null; }
}
protected override void OnEventWritten(EventWrittenEventArgs eventData)
{
_eventWritten?.Invoke(eventData);
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Threading.Tasks;
namespace System.Diagnostics.Tracing
{
/// <summary>Simple event listener than invokes a callback for each event received.</summary>
internal sealed class TestEventListener : EventListener
{
private class Settings
{
public EventLevel Level;
public EventKeywords Keywords;
}
private readonly Dictionary<string, Settings> _names = new Dictionary<string, Settings>();
private readonly Dictionary<Guid, Settings> _guids = new Dictionary<Guid, Settings>();
private readonly double? _eventCounterInterval;
private Action<EventWrittenEventArgs> _eventWritten;
private readonly List<EventSource> _eventSourceList = new List<EventSource>();
public TestEventListener(string targetSourceName, EventLevel level, double? eventCounterInterval = null)
{
_eventCounterInterval = eventCounterInterval;
AddSource(targetSourceName, level);
}
public TestEventListener(Guid targetSourceGuid, EventLevel level, double? eventCounterInterval = null)
{
_eventCounterInterval = eventCounterInterval;
AddSource(targetSourceGuid, level);
}
public void AddSource(string name, EventLevel level, EventKeywords keywords = EventKeywords.All) =>
AddSource(name, null, level, keywords);
public void AddSource(Guid guid, EventLevel level, EventKeywords keywords = EventKeywords.All) =>
AddSource(null, guid, level, keywords);
private void AddSource(string name, Guid? guid, EventLevel level, EventKeywords keywords)
{
EventSource sourceToEnable = null;
lock (_eventSourceList)
{
var settings = new Settings()
{
Level = level,
Keywords = keywords
};
if (name is not null)
_names.Add(name, settings);
if (guid.HasValue)
_guids.Add(guid.Value, settings);
foreach (EventSource source in _eventSourceList)
{
if (name == source.Name || guid == source.Guid)
{
sourceToEnable = source;
break;
}
}
}
if (sourceToEnable != null)
{
EnableEventSource(sourceToEnable, level, keywords);
}
}
public void AddActivityTracking() =>
AddSource("System.Threading.Tasks.TplEventSource", EventLevel.Informational, (EventKeywords)0x80 /* TasksFlowActivityIds */);
protected override void OnEventSourceCreated(EventSource eventSource)
{
bool shouldEnable = false;
Settings settings;
lock (_eventSourceList)
{
_eventSourceList.Add(eventSource);
shouldEnable = _names.TryGetValue(eventSource.Name, out settings) || _guids.TryGetValue(eventSource.Guid, out settings);
}
if (shouldEnable)
{
EnableEventSource(eventSource, settings.Level, settings.Keywords);
}
}
private void EnableEventSource(EventSource source, EventLevel level, EventKeywords keywords)
{
var args = new Dictionary<string, string>();
if (_eventCounterInterval != null)
{
args.Add("EventCounterIntervalSec", _eventCounterInterval.ToString());
}
EnableEvents(source, level, keywords, args);
}
public void RunWithCallback(Action<EventWrittenEventArgs> handler, Action body)
{
_eventWritten = handler;
try { body(); }
finally { _eventWritten = null; }
}
public async Task RunWithCallbackAsync(Action<EventWrittenEventArgs> handler, Func<Task> body)
{
_eventWritten = handler;
try { await body().ConfigureAwait(false); }
finally { _eventWritten = null; }
}
protected override void OnEventWritten(EventWrittenEventArgs eventData)
{
_eventWritten?.Invoke(eventData);
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Text.RegularExpressions/src/System.Text.RegularExpressions.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<TargetFramework>$(NetCoreAppCurrent)</TargetFramework>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<Compile Include="System\Collections\HashtableExtensions.cs" />
<Compile Include="System\Collections\Generic\ValueListBuilder.Pop.cs" />
<Compile Include="System\Threading\StackHelper.cs" />
<Compile Include="System\Text\SegmentStringBuilder.cs" />
<Compile Include="System\Text\RegularExpressions\Capture.cs" />
<Compile Include="System\Text\RegularExpressions\CaptureCollection.cs" />
<Compile Include="System\Text\RegularExpressions\CollectionDebuggerProxy.cs" />
<Compile Include="System\Text\RegularExpressions\Group.cs" />
<Compile Include="System\Text\RegularExpressions\GroupCollection.cs" />
<Compile Include="System\Text\RegularExpressions\Match.cs" />
<Compile Include="System\Text\RegularExpressions\MatchCollection.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Cache.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Count.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Debug.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Match.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Replace.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Split.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Timeout.cs" />
<Compile Include="System\Text\RegularExpressions\RegexCharClass.cs" />
<Compile Include="System\Text\RegularExpressions\RegexCharClass.MappingTable.cs" />
<Compile Include="System\Text\RegularExpressions\RegexCompilationInfo.cs" />
<Compile Include="System\Text\RegularExpressions\RegexFindOptimizations.cs" />
<Compile Include="System\Text\RegularExpressions\RegexGeneratorAttribute.cs" />
<Compile Include="System\Text\RegularExpressions\RegexInterpreter.cs" />
<Compile Include="System\Text\RegularExpressions\RegexInterpreterCode.cs" />
<Compile Include="System\Text\RegularExpressions\RegexMatchTimeoutException.cs" />
<Compile Include="System\Text\RegularExpressions\RegexNode.cs" />
<Compile Include="System\Text\RegularExpressions\RegexNodeKind.cs" />
<Compile Include="System\Text\RegularExpressions\RegexOpcode.cs" />
<Compile Include="System\Text\RegularExpressions\RegexOptions.cs" />
<Compile Include="System\Text\RegularExpressions\RegexParseError.cs" />
<Compile Include="System\Text\RegularExpressions\RegexParseException.cs" />
<Compile Include="System\Text\RegularExpressions\RegexParser.cs" />
<Compile Include="System\Text\RegularExpressions\RegexPrefixAnalyzer.cs" />
<Compile Include="System\Text\RegularExpressions\RegexReplacement.cs" />
<Compile Include="System\Text\RegularExpressions\RegexRunner.cs" />
<Compile Include="System\Text\RegularExpressions\RegexRunnerFactory.cs" />
<Compile Include="System\Text\RegularExpressions\RegexTree.cs" />
<Compile Include="System\Text\RegularExpressions\RegexTreeAnalyzer.cs" />
<Compile Include="System\Text\RegularExpressions\RegexWriter.cs" />
<Compile Include="System\Text\RegularExpressions\ThrowHelper.cs" />
<!-- RegexOptions.Compiled -->
<Compile Include="System\Text\RegularExpressions\CompiledRegexRunnerFactory.cs" />
<Compile Include="System\Text\RegularExpressions\CompiledRegexRunner.cs" />
<Compile Include="System\Text\RegularExpressions\RegexCompiler.cs" />
<Compile Include="System\Text\RegularExpressions\RegexLWCGCompiler.cs" />
<!-- RegexOptions.NonBacktracking -->
<Compile Include="System\Text\RegularExpressions\Symbolic\BDD.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BDDAlgebra.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BDDRangeConverter.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BooleanClassifier.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BitVector.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BitVector64Algebra.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BitVectorAlgebra.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\CharKind.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\CharSetSolver.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\DerivativeEffect.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\DfaMatchingState.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\IBooleanAlgebra.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\ICharAlgebra.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\MintermClassifier.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\MintermGenerator.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\RegexNodeConverter.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SparseIntMap.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicMatch.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicNFA.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexBuilder.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexNode.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexKind.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexInfo.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexMatcher.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexRunnerFactory.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexSampler.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexSet.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\TransitionRegex.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\TransitionRegexKind.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Dgml\DgmlWriter.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Dgml\IAutomaton.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Dgml\Move.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Dgml\RegexAutomaton.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\GeneratorHelper.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\IgnoreCaseRelation.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\IgnoreCaseRelationGenerator.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\IgnoreCaseTransformer.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\UnicodeCategoryRanges.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\UnicodeCategoryRangesGenerator.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\UnicodeCategoryTheory.cs" />
<!-- Common or Common-branched source files -->
<Compile Include="$(CommonPath)System\HexConverter.cs" Link="Common\System\HexConverter.cs" />
<Compile Include="$(CommonPath)System\NotImplemented.cs" Link="Common\System\NotImplemented.cs" />
<Compile Include="$(CommonPath)System\Obsoletions.cs" Link="Common\System\Obsoletions.cs" />
<Compile Include="$(CommonPath)System\Text\ValueStringBuilder.cs" Link="Common\System\Text\ValueStringBuilder.cs" />
<Compile Include="$(CoreLibSharedDir)System\Collections\Generic\ValueListBuilder.cs" Link="Common\System\Collections\Generic\ValueListBuilder.cs" />
</ItemGroup>
<ItemGroup>
<Reference Include="System.Collections" />
<Reference Include="System.Collections.Concurrent" />
<Reference Include="System.Memory" />
<Reference Include="System.Runtime" />
<Reference Include="System.Runtime.Extensions" />
<Reference Include="System.Runtime.InteropServices" />
<Reference Include="System.Threading" />
<!-- References required for RegexOptions.Compiled -->
<Reference Include="System.Reflection.Emit" />
<Reference Include="System.Reflection.Emit.ILGeneration" />
<Reference Include="System.Reflection.Emit.Lightweight" />
<Reference Include="System.Reflection.Primitives" />
<!-- Adding the source generator as an analyzer reference -->
<AnalyzerReference Include="..\gen\System.Text.RegularExpressions.Generator.csproj" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<TargetFramework>$(NetCoreAppCurrent)</TargetFramework>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<Compile Include="System\Collections\HashtableExtensions.cs" />
<Compile Include="System\Collections\Generic\ValueListBuilder.Pop.cs" />
<Compile Include="System\Threading\StackHelper.cs" />
<Compile Include="System\Text\SegmentStringBuilder.cs" />
<Compile Include="System\Text\RegularExpressions\Capture.cs" />
<Compile Include="System\Text\RegularExpressions\CaptureCollection.cs" />
<Compile Include="System\Text\RegularExpressions\CollectionDebuggerProxy.cs" />
<Compile Include="System\Text\RegularExpressions\Group.cs" />
<Compile Include="System\Text\RegularExpressions\GroupCollection.cs" />
<Compile Include="System\Text\RegularExpressions\Match.cs" />
<Compile Include="System\Text\RegularExpressions\MatchCollection.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Cache.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Count.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Debug.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Match.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Replace.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Split.cs" />
<Compile Include="System\Text\RegularExpressions\Regex.Timeout.cs" />
<Compile Include="System\Text\RegularExpressions\RegexCharClass.cs" />
<Compile Include="System\Text\RegularExpressions\RegexCharClass.MappingTable.cs" />
<Compile Include="System\Text\RegularExpressions\RegexCompilationInfo.cs" />
<Compile Include="System\Text\RegularExpressions\RegexFindOptimizations.cs" />
<Compile Include="System\Text\RegularExpressions\RegexGeneratorAttribute.cs" />
<Compile Include="System\Text\RegularExpressions\RegexInterpreter.cs" />
<Compile Include="System\Text\RegularExpressions\RegexInterpreterCode.cs" />
<Compile Include="System\Text\RegularExpressions\RegexMatchTimeoutException.cs" />
<Compile Include="System\Text\RegularExpressions\RegexNode.cs" />
<Compile Include="System\Text\RegularExpressions\RegexNodeKind.cs" />
<Compile Include="System\Text\RegularExpressions\RegexOpcode.cs" />
<Compile Include="System\Text\RegularExpressions\RegexOptions.cs" />
<Compile Include="System\Text\RegularExpressions\RegexParseError.cs" />
<Compile Include="System\Text\RegularExpressions\RegexParseException.cs" />
<Compile Include="System\Text\RegularExpressions\RegexParser.cs" />
<Compile Include="System\Text\RegularExpressions\RegexPrefixAnalyzer.cs" />
<Compile Include="System\Text\RegularExpressions\RegexReplacement.cs" />
<Compile Include="System\Text\RegularExpressions\RegexRunner.cs" />
<Compile Include="System\Text\RegularExpressions\RegexRunnerFactory.cs" />
<Compile Include="System\Text\RegularExpressions\RegexTree.cs" />
<Compile Include="System\Text\RegularExpressions\RegexTreeAnalyzer.cs" />
<Compile Include="System\Text\RegularExpressions\RegexWriter.cs" />
<Compile Include="System\Text\RegularExpressions\ThrowHelper.cs" />
<!-- RegexOptions.Compiled -->
<Compile Include="System\Text\RegularExpressions\CompiledRegexRunnerFactory.cs" />
<Compile Include="System\Text\RegularExpressions\CompiledRegexRunner.cs" />
<Compile Include="System\Text\RegularExpressions\RegexCompiler.cs" />
<Compile Include="System\Text\RegularExpressions\RegexLWCGCompiler.cs" />
<!-- RegexOptions.NonBacktracking -->
<Compile Include="System\Text\RegularExpressions\Symbolic\BDD.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BDDAlgebra.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BDDRangeConverter.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BooleanClassifier.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BitVector.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BitVector64Algebra.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\BitVectorAlgebra.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\CharKind.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\CharSetSolver.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\DerivativeEffect.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\DgmlWriter.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\DfaMatchingState.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\IBooleanAlgebra.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\ICharAlgebra.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\MintermClassifier.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\MintermGenerator.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\RegexNodeConverter.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SparseIntMap.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicMatch.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicNFA.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexBuilder.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexNode.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexKind.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexInfo.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexMatcher.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexRunnerFactory.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexSampler.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\SymbolicRegexSet.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\TransitionRegex.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\TransitionRegexKind.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\GeneratorHelper.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\IgnoreCaseRelation.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\IgnoreCaseRelationGenerator.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\IgnoreCaseTransformer.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\UnicodeCategoryRanges.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\UnicodeCategoryRangesGenerator.cs" />
<Compile Include="System\Text\RegularExpressions\Symbolic\Unicode\UnicodeCategoryTheory.cs" />
<!-- Common or Common-branched source files -->
<Compile Include="$(CommonPath)System\HexConverter.cs" Link="Common\System\HexConverter.cs" />
<Compile Include="$(CommonPath)System\NotImplemented.cs" Link="Common\System\NotImplemented.cs" />
<Compile Include="$(CommonPath)System\Obsoletions.cs" Link="Common\System\Obsoletions.cs" />
<Compile Include="$(CommonPath)System\Text\ValueStringBuilder.cs" Link="Common\System\Text\ValueStringBuilder.cs" />
<Compile Include="$(CoreLibSharedDir)System\Collections\Generic\ValueListBuilder.cs" Link="Common\System\Collections\Generic\ValueListBuilder.cs" />
</ItemGroup>
<ItemGroup>
<Reference Include="System.Collections" />
<Reference Include="System.Collections.Concurrent" />
<Reference Include="System.Memory" />
<Reference Include="System.Runtime" />
<Reference Include="System.Runtime.Extensions" />
<Reference Include="System.Runtime.InteropServices" />
<Reference Include="System.Threading" />
<!-- References required for RegexOptions.Compiled -->
<Reference Include="System.Reflection.Emit" />
<Reference Include="System.Reflection.Emit.ILGeneration" />
<Reference Include="System.Reflection.Emit.Lightweight" />
<Reference Include="System.Reflection.Primitives" />
<!-- Adding the source generator as an analyzer reference -->
<AnalyzerReference Include="..\gen\System.Text.RegularExpressions.Generator.csproj" />
</ItemGroup>
</Project>
| 1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Debug.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#if DEBUG
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Text.RegularExpressions.Symbolic;
using System.Text.RegularExpressions.Symbolic.Unicode;
namespace System.Text.RegularExpressions
{
public partial class Regex
{
/// <summary>True if debug tracing should be enabled, only in debug builds.</summary>
[ExcludeFromCodeCoverage(Justification = "Debug only")]
internal static bool EnableDebugTracing
{
// These members aren't used from IsDebug, but we want to keep them in debug builds for now,
// so this is a convenient place to include them rather than needing a debug-only illink file.
[DynamicDependency(nameof(SaveDGML))]
[DynamicDependency(nameof(GenerateUnicodeTables))]
[DynamicDependency(nameof(GenerateRandomMembers))]
get;
set;
}
/// <summary>Unwind the regex and save the resulting state graph in DGML</summary>
/// <param name="bound">roughly the maximum number of states, 0 means no bound</param>
/// <param name="hideStateInfo">if true then hide state info</param>
/// <param name="addDotStar">if true then pretend that there is a .* at the beginning</param>
/// <param name="inReverse">if true then unwind the regex backwards (addDotStar is then ignored)</param>
/// <param name="onlyDFAinfo">if true then compute and save only general DFA info</param>
/// <param name="writer">dgml output is written here</param>
/// <param name="maxLabelLength">maximum length of labels in nodes anything over that length is indicated with .. </param>
/// <param name="asNFA">if true creates NFA instead of DFA</param>
[ExcludeFromCodeCoverage(Justification = "Debug only")]
internal void SaveDGML(TextWriter writer, int bound, bool hideStateInfo, bool addDotStar, bool inReverse, bool onlyDFAinfo, int maxLabelLength, bool asNFA)
{
if (factory is not SymbolicRegexRunnerFactory srmFactory)
{
throw new NotSupportedException();
}
srmFactory._matcher.SaveDGML(writer, bound, hideStateInfo, addDotStar, inReverse, onlyDFAinfo, maxLabelLength, asNFA);
}
/// <summary>
/// Generates two files IgnoreCaseRelation.cs and UnicodeCategoryRanges.cs for the namespace System.Text.RegularExpressions.Symbolic.Unicode
/// in the given directory path. Only avaliable in DEBUG mode.
/// </summary>
[ExcludeFromCodeCoverage(Justification = "Debug only")]
internal static void GenerateUnicodeTables(string path)
{
IgnoreCaseRelationGenerator.Generate("System.Text.RegularExpressions.Symbolic.Unicode", "IgnoreCaseRelation", path);
UnicodeCategoryRangesGenerator.Generate("System.Text.RegularExpressions.Symbolic.Unicode", "UnicodeCategoryRanges", path);
}
/// <summary>
/// Generates up to k random strings matched by the regex
/// </summary>
/// <param name="k">upper bound on the number of generated strings</param>
/// <param name="randomseed">random seed for the generator, 0 means no random seed</param>
/// <param name="negative">if true then generate inputs that do not match</param>
/// <returns></returns>
[ExcludeFromCodeCoverage(Justification = "Debug only")]
internal IEnumerable<string> GenerateRandomMembers(int k, int randomseed, bool negative)
{
if (factory is not SymbolicRegexRunnerFactory srmFactory)
{
throw new NotSupportedException();
}
return srmFactory._matcher.GenerateRandomMembers(k, randomseed, negative);
}
}
}
#endif
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#if DEBUG
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Text.RegularExpressions.Symbolic;
using System.Text.RegularExpressions.Symbolic.Unicode;
namespace System.Text.RegularExpressions
{
public partial class Regex
{
/// <summary>True if debug tracing should be enabled, only in debug builds.</summary>
[ExcludeFromCodeCoverage(Justification = "Debug only")]
internal static bool EnableDebugTracing
{
// These members aren't used from IsDebug, but we want to keep them in debug builds for now,
// so this is a convenient place to include them rather than needing a debug-only illink file.
[DynamicDependency(nameof(SaveDGML))]
[DynamicDependency(nameof(GenerateUnicodeTables))]
[DynamicDependency(nameof(GenerateRandomMembers))]
get;
set;
}
/// <summary>Unwind the regex and save the resulting state graph in DGML</summary>
/// <param name="writer">Writer to which the DGML is written.</param>
/// <param name="nfa">True to create an NFA instead of a DFA.</param>
/// <param name="addDotStar">True to prepend .*? onto the pattern (outside of the implicit root capture).</param>
/// <param name="reverse">If true, then unwind the regex backwards (and <paramref name="addDotStar"/> is ignored).</param>
/// <param name="maxStates">The approximate maximum number of states to include; less than or equal to 0 for no maximum.</param>
/// <param name="maxLabelLength">maximum length of labels in nodes anything over that length is indicated with .. </param>
[ExcludeFromCodeCoverage(Justification = "Debug only")]
internal void SaveDGML(TextWriter writer, bool nfa, bool addDotStar, bool reverse, int maxStates, int maxLabelLength)
{
if (factory is not SymbolicRegexRunnerFactory srmFactory)
{
throw new NotSupportedException();
}
srmFactory._matcher.SaveDGML(writer, nfa, addDotStar, reverse, maxStates, maxLabelLength);
}
/// <summary>
/// Generates two files IgnoreCaseRelation.cs and UnicodeCategoryRanges.cs for the namespace System.Text.RegularExpressions.Symbolic.Unicode
/// in the given directory path. Only avaliable in DEBUG mode.
/// </summary>
[ExcludeFromCodeCoverage(Justification = "Debug only")]
internal static void GenerateUnicodeTables(string path)
{
IgnoreCaseRelationGenerator.Generate("System.Text.RegularExpressions.Symbolic.Unicode", "IgnoreCaseRelation", path);
UnicodeCategoryRangesGenerator.Generate("System.Text.RegularExpressions.Symbolic.Unicode", "UnicodeCategoryRanges", path);
}
/// <summary>
/// Generates up to k random strings matched by the regex
/// </summary>
/// <param name="k">upper bound on the number of generated strings</param>
/// <param name="randomseed">random seed for the generator, 0 means no random seed</param>
/// <param name="negative">if true then generate inputs that do not match</param>
/// <returns></returns>
[ExcludeFromCodeCoverage(Justification = "Debug only")]
internal IEnumerable<string> GenerateRandomMembers(int k, int randomseed, bool negative)
{
if (factory is not SymbolicRegexRunnerFactory srmFactory)
{
throw new NotSupportedException();
}
return srmFactory._matcher.GenerateRandomMembers(k, randomseed, negative);
}
}
}
#endif
| 1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;
namespace System.Text.RegularExpressions.Symbolic
{
/// <summary>Represents a regex matching engine that performs regex matching using symbolic derivatives.</summary>
internal abstract class SymbolicRegexMatcher
{
#if DEBUG
/// <summary>Unwind the regex of the matcher and save the resulting state graph in DGML</summary>
/// <param name="bound">roughly the maximum number of states, 0 means no bound</param>
/// <param name="hideStateInfo">if true then hide state info</param>
/// <param name="addDotStar">if true then pretend that there is a .* at the beginning</param>
/// <param name="inReverse">if true then unwind the regex backwards (addDotStar is then ignored)</param>
/// <param name="onlyDFAinfo">if true then compute and save only genral DFA info</param>
/// <param name="writer">dgml output is written here</param>
/// <param name="maxLabelLength">maximum length of labels in nodes anything over that length is indicated with .. </param>
/// <param name="asNFA">if true creates NFA instead of DFA</param>
public abstract void SaveDGML(TextWriter writer, int bound, bool hideStateInfo, bool addDotStar, bool inReverse, bool onlyDFAinfo, int maxLabelLength, bool asNFA);
/// <summary>
/// Generates up to k random strings matched by the regex
/// </summary>
/// <param name="k">upper bound on the number of generated strings</param>
/// <param name="randomseed">random seed for the generator, 0 means no random seed</param>
/// <param name="negative">if true then generate inputs that do not match</param>
/// <returns></returns>
public abstract IEnumerable<string> GenerateRandomMembers(int k, int randomseed, bool negative);
#endif
}
/// <summary>Represents a regex matching engine that performs regex matching using symbolic derivatives.</summary>
/// <typeparam name="TSetType">Character set type.</typeparam>
internal sealed class SymbolicRegexMatcher<TSetType> : SymbolicRegexMatcher where TSetType : notnull
{
/// <summary>Maximum number of built states before switching over to NFA mode.</summary>
/// <remarks>
/// By default, all matching starts out using DFAs, where every state transitions to one and only one
/// state for any minterm (each character maps to one minterm). Some regular expressions, however, can result
/// in really, really large DFA state graphs, much too big to actually store. Instead of failing when we
/// encounter such state graphs, at some point we instead switch from processing as a DFA to processing as
/// an NFA. As an NFA, we instead track all of the states we're in at any given point, and transitioning
/// from one "state" to the next really means for every constituent state that composes our current "state",
/// we find all possible states that transitioning out of each of them could result in, and the union of
/// all of those is our new "state". This constant represents the size of the graph after which we start
/// processing as an NFA instead of as a DFA. This processing doesn't change immediately, however. All
/// processing starts out in DFA mode, even if we've previously triggered NFA mode for the same regex.
/// We switch over into NFA mode the first time a given traversal (match operation) results in us needing
/// to create a new node and the graph is already or newly beyond this threshold.
/// </remarks>
internal const int NfaThreshold = 10_000;
/// <summary>Sentinel value used internally by the matcher to indicate no match exists.</summary>
private const int NoMatchExists = -2;
/// <summary>Builder used to create <see cref="SymbolicRegexNode{S}"/>s while matching.</summary>
/// <remarks>
/// The builder is used to build up the DFA state space lazily, which means we need to be able to
/// produce new <see cref="SymbolicRegexNode{S}"/>s as we match. Once in NFA mode, we also use
/// the builder to produce new NFA states. The builder maintains a cache of all DFA and NFA states.
/// </remarks>
internal readonly SymbolicRegexBuilder<TSetType> _builder;
/// <summary>Maps every character to its corresponding minterm ID.</summary>
private readonly MintermClassifier _mintermClassifier;
/// <summary><see cref="_pattern"/> prefixed with [0-0xFFFF]*</summary>
/// <remarks>
/// The matching engine first uses <see cref="_dotStarredPattern"/> to find whether there is a match
/// and where that match might end. Prepending the .* prefix onto the original pattern provides the DFA
/// with the ability to continue to process input characters even if those characters aren't part of
/// the match. If Regex.IsMatch is used, nothing further is needed beyond this prefixed pattern. If, however,
/// other matching operations are performed that require knowing the exact start and end of the match,
/// the engine then needs to process the pattern in reverse to find where the match actually started;
/// for that, it uses the <see cref="_reversePattern"/> and walks backwards through the input characters
/// from where <see cref="_dotStarredPattern"/> left off. At this point we know that there was a match,
/// where it started, and where it could have ended, but that ending point could be influenced by the
/// selection of the starting point. So, to find the actual ending point, the original <see cref="_pattern"/>
/// is then used from that starting point to walk forward through the input characters again to find the
/// actual end point used for the match.
/// </remarks>
internal readonly SymbolicRegexNode<TSetType> _dotStarredPattern;
/// <summary>The original regex pattern.</summary>
internal readonly SymbolicRegexNode<TSetType> _pattern;
/// <summary>The reverse of <see cref="_pattern"/>.</summary>
/// <remarks>
/// Determining that there is a match and where the match ends requires only <see cref="_pattern"/>.
/// But from there determining where the match began requires reversing the pattern and running
/// the matcher again, starting from the ending position. This <see cref="_reversePattern"/> caches
/// that reversed pattern used for extracting match start.
/// </remarks>
internal readonly SymbolicRegexNode<TSetType> _reversePattern;
/// <summary>true iff timeout checking is enabled.</summary>
private readonly bool _checkTimeout;
/// <summary>Timeout in milliseconds. This is only used if <see cref="_checkTimeout"/> is true.</summary>
private readonly int _timeout;
/// <summary>Data and routines for skipping ahead to the next place a match could potentially start.</summary>
private readonly RegexFindOptimizations? _findOpts;
/// <summary>The initial states for the original pattern, keyed off of the previous character kind.</summary>
/// <remarks>If the pattern doesn't contain any anchors, there will only be a single initial state.</remarks>
private readonly DfaMatchingState<TSetType>[] _initialStates;
/// <summary>The initial states for the dot-star pattern, keyed off of the previous character kind.</summary>
/// <remarks>If the pattern doesn't contain any anchors, there will only be a single initial state.</remarks>
private readonly DfaMatchingState<TSetType>[] _dotstarredInitialStates;
/// <summary>The initial states for the reverse pattern, keyed off of the previous character kind.</summary>
/// <remarks>If the pattern doesn't contain any anchors, there will only be a single initial state.</remarks>
private readonly DfaMatchingState<TSetType>[] _reverseInitialStates;
/// <summary>Lookup table to quickly determine the character kind for ASCII characters.</summary>
/// <remarks>Non-null iff the pattern contains anchors; otherwise, it's unused.</remarks>
private readonly uint[]? _asciiCharKinds;
/// <summary>Number of capture groups.</summary>
private readonly int _capsize;
/// <summary>Fixed-length of any possible match.</summary>
/// <remarks>This will be null if matches may be of varying lengths or if a fixed-length couldn't otherwise be computed.</remarks>
private readonly int? _fixedMatchLength;
/// <summary>Gets whether the regular expression contains captures (beyond the implicit root-level capture).</summary>
/// <remarks>This determines whether the matcher uses the special capturing NFA simulation mode.</remarks>
internal bool HasSubcaptures => _capsize > 1;
/// <summary>Get the minterm of <paramref name="c"/>.</summary>
/// <param name="c">character code</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private TSetType GetMinterm(int c)
{
Debug.Assert(_builder._minterms is not null);
return _builder._minterms[_mintermClassifier.GetMintermID(c)];
}
/// <summary>Constructs matcher for given symbolic regex.</summary>
internal SymbolicRegexMatcher(SymbolicRegexNode<TSetType> sr, RegexTree regexTree, BDD[] minterms, TimeSpan matchTimeout)
{
Debug.Assert(sr._builder._solver is BitVector64Algebra or BitVectorAlgebra or CharSetSolver, $"Unsupported algebra: {sr._builder._solver}");
_pattern = sr;
_builder = sr._builder;
_checkTimeout = Regex.InfiniteMatchTimeout != matchTimeout;
_timeout = (int)(matchTimeout.TotalMilliseconds + 0.5); // Round up, so it will be at least 1ms
_mintermClassifier = _builder._solver switch
{
BitVector64Algebra bv64 => bv64._classifier,
BitVectorAlgebra bv => bv._classifier,
_ => new MintermClassifier((CharSetSolver)(object)_builder._solver, minterms),
};
_capsize = regexTree.CaptureCount;
if (regexTree.FindOptimizations.MinRequiredLength == regexTree.FindOptimizations.MaxPossibleLength)
{
_fixedMatchLength = regexTree.FindOptimizations.MinRequiredLength;
}
if (regexTree.FindOptimizations.FindMode != FindNextStartingPositionMode.NoSearch &&
regexTree.FindOptimizations.LeadingAnchor == 0) // If there are any anchors, we're better off letting the DFA quickly do its job of determining whether there's a match.
{
_findOpts = regexTree.FindOptimizations;
}
// Determine the number of initial states. If there's no anchor, only the default previous
// character kind 0 is ever going to be used for all initial states.
int statesCount = _pattern._info.ContainsSomeAnchor ? CharKind.CharKindCount : 1;
// Create the initial states for the original pattern.
var initialStates = new DfaMatchingState<TSetType>[statesCount];
for (uint i = 0; i < initialStates.Length; i++)
{
initialStates[i] = _builder.CreateState(_pattern, i, capturing: HasSubcaptures);
}
_initialStates = initialStates;
// Create the dot-star pattern (a concatenation of any* with the original pattern)
// and all of its initial states.
_dotStarredPattern = _builder.CreateConcat(_builder._anyStar, _pattern);
var dotstarredInitialStates = new DfaMatchingState<TSetType>[statesCount];
for (uint i = 0; i < dotstarredInitialStates.Length; i++)
{
// Used to detect if initial state was reentered,
// but observe that the behavior from the state may ultimately depend on the previous
// input char e.g. possibly causing nullability of \b or \B or of a start-of-line anchor,
// in that sense there can be several "versions" (not more than StateCount) of the initial state.
DfaMatchingState<TSetType> state = _builder.CreateState(_dotStarredPattern, i, capturing: false);
state.IsInitialState = true;
dotstarredInitialStates[i] = state;
}
_dotstarredInitialStates = dotstarredInitialStates;
// Create the reverse pattern (the original pattern in reverse order) and all of its
// initial states. Also disable backtracking simulation to ensure the reverse path from
// the final state that was found is followed. Not doing so might cause the earliest
// starting point to not be found.
_reversePattern = _builder.CreateDisableBacktrackingSimulation(_pattern.Reverse());
var reverseInitialStates = new DfaMatchingState<TSetType>[statesCount];
for (uint i = 0; i < reverseInitialStates.Length; i++)
{
reverseInitialStates[i] = _builder.CreateState(_reversePattern, i, capturing: false);
}
_reverseInitialStates = reverseInitialStates;
// Initialize our fast-lookup for determining the character kind of ASCII characters.
// This is only required when the pattern contains anchors, as otherwise there's only
// ever a single kind used.
if (_pattern._info.ContainsSomeAnchor)
{
var asciiCharKinds = new uint[128];
for (int i = 0; i < asciiCharKinds.Length; i++)
{
TSetType predicate2;
uint charKind;
if (i == '\n')
{
predicate2 = _builder._newLinePredicate;
charKind = CharKind.Newline;
}
else
{
predicate2 = _builder._wordLetterPredicateForAnchors;
charKind = CharKind.WordLetter;
}
asciiCharKinds[i] = _builder._solver.And(GetMinterm(i), predicate2).Equals(_builder._solver.False) ? 0 : charKind;
}
_asciiCharKinds = asciiCharKinds;
}
}
/// <summary>
/// Create a PerThreadData with the appropriate parts initialized for this matcher's pattern.
/// </summary>
internal PerThreadData CreatePerThreadData() => new PerThreadData(_builder, _capsize);
/// <summary>Compute the target state for the source state and input[i] character and transition to it.</summary>
/// <param name="builder">The associated builder.</param>
/// <param name="input">The input text.</param>
/// <param name="i">The index into <paramref name="input"/> at which the target character lives.</param>
/// <param name="state">The current state being transitioned from. Upon return it's the new state if the transition succeeded.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private bool TryTakeTransition<TStateHandler>(SymbolicRegexBuilder<TSetType> builder, ReadOnlySpan<char> input, int i, ref CurrentState state)
where TStateHandler : struct, IStateHandler
{
int c = input[i];
int mintermId = c == '\n' && i == input.Length - 1 && TStateHandler.StartsWithLineAnchor(ref state) ?
builder._minterms!.Length : // mintermId = minterms.Length represents \Z (last \n)
_mintermClassifier.GetMintermID(c);
return TStateHandler.TakeTransition(builder, ref state, mintermId);
}
private List<(DfaMatchingState<TSetType>, DerivativeEffect[])> CreateNewCapturingTransitions(DfaMatchingState<TSetType> state, TSetType minterm, int offset)
{
Debug.Assert(_builder._capturingDelta is not null);
lock (this)
{
// Get the next state if it exists. The caller should have already tried and found it null (not yet created),
// but in the interim another thread could have created it.
List<(DfaMatchingState<TSetType>, DerivativeEffect[])>? p = _builder._capturingDelta[offset];
if (p is null)
{
// Build the new state and store it into the array.
p = state.NfaNextWithEffects(minterm);
Volatile.Write(ref _builder._capturingDelta[offset], p);
}
return p;
}
}
private void DoCheckTimeout(int timeoutOccursAt)
{
// This logic is identical to RegexRunner.DoCheckTimeout, with the exception of check skipping. RegexRunner calls
// DoCheckTimeout potentially on every iteration of a loop, whereas this calls it only once per transition.
int currentMillis = Environment.TickCount;
if (currentMillis >= timeoutOccursAt && (0 <= timeoutOccursAt || 0 >= currentMillis))
{
throw new RegexMatchTimeoutException(string.Empty, string.Empty, TimeSpan.FromMilliseconds(_timeout));
}
}
/// <summary>Find a match.</summary>
/// <param name="isMatch">Whether to return once we know there's a match without determining where exactly it matched.</param>
/// <param name="input">The input span</param>
/// <param name="startat">The position to start search in the input span.</param>
/// <param name="perThreadData">Per thread data reused between calls.</param>
public SymbolicMatch FindMatch(bool isMatch, ReadOnlySpan<char> input, int startat, PerThreadData perThreadData)
{
Debug.Assert(startat >= 0 && startat <= input.Length, $"{nameof(startat)} == {startat}, {nameof(input.Length)} == {input.Length}");
Debug.Assert(perThreadData is not null);
// If we need to perform timeout checks, store the absolute timeout value.
int timeoutOccursAt = 0;
if (_checkTimeout)
{
// Using Environment.TickCount for efficiency instead of Stopwatch -- as in the non-DFA case.
timeoutOccursAt = Environment.TickCount + (int)(_timeout + 0.5);
}
// If we're starting at the end of the input, we don't need to do any work other than
// determine whether an empty match is valid, i.e. whether the pattern is "nullable"
// given the kinds of characters at and just before the end.
if (startat == input.Length)
{
// TODO https://github.com/dotnet/runtime/issues/65606: Handle capture groups.
uint prevKind = GetCharKind(input, startat - 1);
uint nextKind = GetCharKind(input, startat);
return _pattern.IsNullableFor(CharKind.Context(prevKind, nextKind)) ?
new SymbolicMatch(startat, 0) :
SymbolicMatch.NoMatch;
}
// Phase 1:
// Determine whether there is a match by finding the first final state position. This only tells
// us whether there is a match but needn't give us the longest possible match. This may return -1 as
// a legitimate value when the initial state is nullable and startat == 0. It returns NoMatchExists (-2)
// when there is no match. As an example, consider the pattern a{5,10}b* run against an input
// of aaaaaaaaaaaaaaabbbc: phase 1 will find the position of the first b: aaaaaaaaaaaaaaab.
int i = FindFinalStatePosition(input, startat, timeoutOccursAt, out int matchStartLowBoundary, out int matchStartLengthMarker, perThreadData);
// If there wasn't a match, we're done.
if (i == NoMatchExists)
{
return SymbolicMatch.NoMatch;
}
// A match exists. If we don't need further details, because IsMatch was used (and thus we don't
// need the exact bounds of the match, captures, etc.), we're done.
if (isMatch)
{
return SymbolicMatch.QuickMatch;
}
// Phase 2:
// Match backwards through the input matching against the reverse of the pattern, looking for the earliest
// start position. That tells us the actual starting position of the match. We can skip this phase if we
// recorded a fixed-length marker for the portion of the pattern that matched, as we can then jump that
// exact number of positions backwards. Continuing the previous example, phase 2 will walk backwards from
// that first b until it finds the 6th a: aaaaaaaaaab.
int matchStart;
if (matchStartLengthMarker >= 0)
{
matchStart = i - matchStartLengthMarker + 1;
}
else
{
Debug.Assert(i >= startat - 1);
matchStart = i < startat ?
startat :
FindStartPosition(input, i, matchStartLowBoundary, perThreadData);
}
// Phase 3:
// Match again, this time from the computed start position, to find the latest end position. That start
// and end then represent the bounds of the match. If the pattern has subcaptures (captures other than
// the top-level capture for the whole match), we need to do more work to compute their exact bounds, so we
// take a faster path if captures aren't required. Further, if captures aren't needed, and if any possible
// match of the whole pattern is a fixed length, we can skip this phase as well, just using that fixed-length
// to compute the ending position based on the starting position. Continuing the previous example, phase 3
// will walk forwards from the 6th a until it finds the end of the match: aaaaaaaaaabbb.
if (!HasSubcaptures)
{
if (_fixedMatchLength.HasValue)
{
return new SymbolicMatch(matchStart, _fixedMatchLength.GetValueOrDefault());
}
int matchEnd = FindEndPosition(input, matchStart, perThreadData);
return new SymbolicMatch(matchStart, matchEnd + 1 - matchStart);
}
else
{
int matchEnd = FindEndPositionCapturing(input, matchStart, out Registers endRegisters, perThreadData);
return new SymbolicMatch(matchStart, matchEnd + 1 - matchStart, endRegisters.CaptureStarts, endRegisters.CaptureEnds);
}
}
/// <summary>Phase 3 of matching. From a found starting position, find the ending position of the match using the original pattern.</summary>
/// <remarks>
/// The ending position is known to exist; this function just needs to determine exactly what it is.
/// We need to find the longest possible match and thus the latest valid ending position.
/// </remarks>
/// <param name="input">The input text.</param>
/// <param name="i">The starting position of the match.</param>
/// <param name="perThreadData">Per thread data reused between calls.</param>
/// <returns>The found ending position of the match.</returns>
private int FindEndPosition(ReadOnlySpan<char> input, int i, PerThreadData perThreadData)
{
// Get the starting state based on the current context.
DfaMatchingState<TSetType> dfaStartState = _initialStates[GetCharKind(input, i - 1)];
// If the starting state is nullable (accepts the empty string), then it's a valid
// match and we need to record the position as a possible end, but keep going looking
// for a better one.
int end = input.Length; // invalid sentinel value
if (dfaStartState.IsNullable(GetCharKind(input, i)))
{
// Empty match exists because the initial state is accepting.
end = i - 1;
}
if ((uint)i < (uint)input.Length)
{
// Iterate from the starting state until we've found the best ending state.
SymbolicRegexBuilder<TSetType> builder = dfaStartState.Node._builder;
var currentState = new CurrentState(dfaStartState);
while (true)
{
// Run the DFA or NFA traversal backwards from the current point using the current state.
bool done = currentState.NfaState is not null ?
FindEndPositionDeltas<NfaStateHandler>(builder, input, ref i, ref currentState, ref end) :
FindEndPositionDeltas<DfaStateHandler>(builder, input, ref i, ref currentState, ref end);
// If we successfully found the ending position, we're done.
if (done || (uint)i >= (uint)input.Length)
{
break;
}
// We exited out of the inner processing loop, but we didn't hit a dead end or run out
// of input, and that should only happen if we failed to transition from one state to
// the next, which should only happen if we were in DFA mode and we tried to create
// a new state and exceeded the graph size. Upgrade to NFA mode and continue;
Debug.Assert(currentState.DfaState is not null);
NfaMatchingState nfaState = perThreadData.NfaState;
nfaState.InitializeFrom(currentState.DfaState);
currentState = new CurrentState(nfaState);
}
}
// Return the found ending position.
Debug.Assert(end < input.Length, "Expected to find an ending position but didn't");
return end;
}
/// <summary>
/// Workhorse inner loop for <see cref="FindEndPosition"/>. Consumes the <paramref name="input"/> character by character,
/// starting at <paramref name="i"/>, for each character transitioning from one state in the DFA or NFA graph to the next state,
/// lazily building out the graph as needed.
/// </summary>
private bool FindEndPositionDeltas<TStateHandler>(SymbolicRegexBuilder<TSetType> builder, ReadOnlySpan<char> input, ref int i, ref CurrentState currentState, ref int endingIndex)
where TStateHandler : struct, IStateHandler
{
// To avoid frequent reads/writes to ref values, make and operate on local copies, which we then copy back once before returning.
int pos = i;
CurrentState state = currentState;
// Repeatedly read the next character from the input and use it to transition the current state to the next.
// We're looking for the furthest final state we can find.
while ((uint)pos < (uint)input.Length && TryTakeTransition<TStateHandler>(builder, input, pos, ref state))
{
if (TStateHandler.IsNullable(ref state, GetCharKind(input, pos + 1)))
{
// If the new state accepts the empty string, we found an ending state. Record the position.
endingIndex = pos;
}
else if (TStateHandler.IsDeadend(ref state))
{
// If the new state is a dead end, the match ended the last time endingIndex was updated.
currentState = state;
i = pos;
return true;
}
// We successfully transitioned to the next state and consumed the current character,
// so move along to the next.
pos++;
}
// We either ran out of input, in which case we successfully recorded an ending index,
// or we failed to transition to the next state due to the graph becoming too large.
currentState = state;
i = pos;
return false;
}
/// <summary>Find match end position using the original pattern, end position is known to exist. This version also produces captures.</summary>
/// <param name="input">input span</param>
/// <param name="i">inclusive start position</param>
/// <param name="resultRegisters">out parameter for the final register values, which indicate capture starts and ends</param>
/// <param name="perThreadData">Per thread data reused between calls.</param>
/// <returns>the match end position</returns>
private int FindEndPositionCapturing(ReadOnlySpan<char> input, int i, out Registers resultRegisters, PerThreadData perThreadData)
{
int i_end = input.Length;
Registers endRegisters = default;
DfaMatchingState<TSetType>? endState = null;
// Pick the correct start state based on previous character kind.
DfaMatchingState<TSetType> initialState = _initialStates[GetCharKind(input, i - 1)];
Registers initialRegisters = perThreadData.InitialRegisters;
// Initialize registers with -1, which means "not seen yet"
Array.Fill(initialRegisters.CaptureStarts, -1);
Array.Fill(initialRegisters.CaptureEnds, -1);
if (initialState.IsNullable(GetCharKind(input, i)))
{
// Empty match exists because the initial state is accepting.
i_end = i - 1;
endRegisters.Assign(initialRegisters);
endState = initialState;
}
// Use two maps from state IDs to register values for the current and next set of states.
// Note that these maps use insertion order, which is used to maintain priorities between states in a way
// that matches the order the backtracking engines visit paths.
Debug.Assert(perThreadData.Current is not null && perThreadData.Next is not null);
SparseIntMap<Registers> current = perThreadData.Current, next = perThreadData.Next;
current.Clear();
next.Clear();
current.Add(initialState.Id, initialRegisters);
SymbolicRegexBuilder<TSetType> builder = _builder;
while ((uint)i < (uint)input.Length)
{
Debug.Assert(next.Count == 0);
int c = input[i];
int normalMintermId = _mintermClassifier.GetMintermID(c);
foreach ((int sourceId, Registers sourceRegisters) in current.Values)
{
Debug.Assert(builder._capturingStateArray is not null);
DfaMatchingState<TSetType> sourceState = builder._capturingStateArray[sourceId];
// Find the minterm, handling the special case for the last \n
int mintermId = c == '\n' && i == input.Length - 1 && sourceState.StartsWithLineAnchor ?
builder._minterms!.Length :
normalMintermId; // mintermId = minterms.Length represents \Z (last \n)
TSetType minterm = builder.GetMinterm(mintermId);
// Get or create the transitions
int offset = (sourceId << builder._mintermsLog) | mintermId;
Debug.Assert(builder._capturingDelta is not null);
List<(DfaMatchingState<TSetType>, DerivativeEffect[])>? transitions =
builder._capturingDelta[offset] ??
CreateNewCapturingTransitions(sourceState, minterm, offset);
// Take the transitions in their prioritized order
for (int j = 0; j < transitions.Count; ++j)
{
(DfaMatchingState<TSetType> targetState, DerivativeEffect[] effects) = transitions[j];
if (targetState.IsDeadend)
continue;
// Try to add the state and handle the case where it didn't exist before. If the state already
// exists, then the transition can be safely ignored, as the existing state was generated by a
// higher priority transition.
if (next.Add(targetState.Id, out int index))
{
// Avoid copying the registers on the last transition from this state, reusing the registers instead
Registers newRegisters = j != transitions.Count - 1 ? sourceRegisters.Clone() : sourceRegisters;
newRegisters.ApplyEffects(effects, i);
next.Update(index, targetState.Id, newRegisters);
if (targetState.IsNullable(GetCharKind(input, i + 1)))
{
// Accepting state has been reached. Record the position.
i_end = i;
endRegisters.Assign(newRegisters);
endState = targetState;
// No lower priority transitions from this or other source states are taken because the
// backtracking engines would return the match ending here.
goto BreakNullable;
}
}
}
}
BreakNullable:
if (next.Count == 0)
{
// If all states died out some nullable state must have been seen before
break;
}
// Swap the state sets and prepare for the next character
SparseIntMap<Registers> tmp = current;
current = next;
next = tmp;
next.Clear();
i++;
}
Debug.Assert(i_end != input.Length && endState is not null);
// Apply effects for finishing at the stored end state
endState.Node.ApplyEffects((effect, args) => args.Registers.ApplyEffect(effect, args.Pos),
CharKind.Context(endState.PrevCharKind, GetCharKind(input, i_end + 1)), (Registers: endRegisters, Pos: i_end + 1));
resultRegisters = endRegisters;
return i_end;
}
/// <summary>
/// Phase 2 of matching. From a found ending position, walk in reverse through the input using the reverse pattern to find the
/// start position of match.
/// </summary>
/// <remarks>
/// The start position is known to exist; this function just needs to determine exactly what it is.
/// We need to find the earliest (lowest index) starting position that's not earlier than <paramref name="matchStartBoundary"/>.
/// </remarks>
/// <param name="input">The input text.</param>
/// <param name="i">The ending position to walk backwards from. <paramref name="i"/> points at the last character of the match.</param>
/// <param name="matchStartBoundary">The initial starting location discovered in phase 1, a point we must not walk earlier than.</param>
/// <param name="perThreadData">Per thread data reused between calls.</param>
/// <returns>The found starting position for the match.</returns>
private int FindStartPosition(ReadOnlySpan<char> input, int i, int matchStartBoundary, PerThreadData perThreadData)
{
Debug.Assert(i >= 0, $"{nameof(i)} == {i}");
Debug.Assert(matchStartBoundary >= 0 && matchStartBoundary < input.Length, $"{nameof(matchStartBoundary)} == {matchStartBoundary}");
Debug.Assert(i >= matchStartBoundary, $"Expected {i} >= {matchStartBoundary}.");
// Get the starting state for the reverse pattern. This depends on previous character (which, because we're
// going backwards, is character number i + 1).
var currentState = new CurrentState(_reverseInitialStates[GetCharKind(input, i + 1)]);
// If the initial state is nullable, meaning it accepts the empty string, then we've already discovered
// a valid starting position, and we just need to keep looking for an earlier one in case there is one.
int lastStart = -1; // invalid sentinel value
if (currentState.DfaState!.IsNullable(GetCharKind(input, i)))
{
lastStart = i + 1;
}
// Walk backwards to the furthest accepting state of the reverse pattern but no earlier than matchStartBoundary.
SymbolicRegexBuilder<TSetType> builder = currentState.DfaState.Node._builder;
while (true)
{
// Run the DFA or NFA traversal backwards from the current point using the current state.
bool done = currentState.NfaState is not null ?
FindStartPositionDeltas<NfaStateHandler>(builder, input, ref i, matchStartBoundary, ref currentState, ref lastStart) :
FindStartPositionDeltas<DfaStateHandler>(builder, input, ref i, matchStartBoundary, ref currentState, ref lastStart);
// If we found the starting position, we're done.
if (done)
{
break;
}
// We didn't find the starting position but we did exit out of the backwards traversal. That should only happen
// if we were unable to transition, which should only happen if we were in DFA mode and exceeded our graph size.
// Upgrade to NFA mode and continue.
Debug.Assert(i >= matchStartBoundary);
Debug.Assert(currentState.DfaState is not null);
NfaMatchingState nfaState = perThreadData.NfaState;
nfaState.InitializeFrom(currentState.DfaState);
currentState = new CurrentState(nfaState);
}
Debug.Assert(lastStart != -1, "We expected to find a starting position but didn't.");
return lastStart;
}
/// <summary>
/// Workhorse inner loop for <see cref="FindStartPosition"/>. Consumes the <paramref name="input"/> character by character in reverse,
/// starting at <paramref name="i"/>, for each character transitioning from one state in the DFA or NFA graph to the next state,
/// lazily building out the graph as needed.
/// </summary>
private bool FindStartPositionDeltas<TStateHandler>(SymbolicRegexBuilder<TSetType> builder, ReadOnlySpan<char> input, ref int i, int startThreshold, ref CurrentState currentState, ref int lastStart)
where TStateHandler : struct, IStateHandler
{
// To avoid frequent reads/writes to ref values, make and operate on local copies, which we then copy back once before returning.
int pos = i;
CurrentState state = currentState;
// Loop backwards through each character in the input, transitioning from state to state for each.
while (TryTakeTransition<TStateHandler>(builder, input, pos, ref state))
{
// We successfully transitioned. If the new state is a dead end, we're done, as we must have already seen
// and recorded a larger lastStart value that was the earliest valid starting position.
if (TStateHandler.IsDeadend(ref state))
{
Debug.Assert(lastStart != -1);
currentState = state;
i = pos;
return true;
}
// If the new state accepts the empty string, we found a valid starting position. Record it and keep going,
// since we're looking for the earliest one to occur within bounds.
if (TStateHandler.IsNullable(ref state, GetCharKind(input, pos - 1)))
{
lastStart = pos;
}
// Since we successfully transitioned, update our current index to match the fact that we consumed the previous character in the input.
pos--;
// If doing so now puts us below the start threshold, bail; we should have already found a valid starting location.
if (pos < startThreshold)
{
Debug.Assert(lastStart != -1);
currentState = state;
i = pos;
return true;
}
}
// Unable to transition further.
currentState = state;
i = pos;
return false;
}
/// <summary>Performs the initial Phase 1 match to find the first final state encountered.</summary>
/// <param name="input">The input text.</param>
/// <param name="i">The starting position in <paramref name="input"/>.</param>
/// <param name="timeoutOccursAt">The time at which timeout occurs, if timeouts are being checked.</param>
/// <param name="initialStateIndex">The last position the initial state of <see cref="_dotStarredPattern"/> was visited.</param>
/// <param name="matchLength">Length of the match if there's a match; otherwise, -1.</param>
/// <param name="perThreadData">Per thread data reused between calls.</param>
/// <returns>The index into input that matches the final state, or NoMatchExists if no match exists. It returns -1 when i=0 and the initial state is nullable.</returns>
private int FindFinalStatePosition(ReadOnlySpan<char> input, int i, int timeoutOccursAt, out int initialStateIndex, out int matchLength, PerThreadData perThreadData)
{
matchLength = -1;
initialStateIndex = i;
// Start with the start state of the dot-star pattern, which in general depends on the previous character kind in the input in order to handle anchors.
// If the starting state is a dead end, then no match exists.
var currentState = new CurrentState(_dotstarredInitialStates[GetCharKind(input, i - 1)]);
if (currentState.DfaState!.IsNothing)
{
// This can happen, for example, when the original regex starts with a beginning anchor but the previous char kind is not Beginning.
return NoMatchExists;
}
// If the starting state accepts the empty string in this context (factoring in anchors), we're done.
if (currentState.DfaState.IsNullable(GetCharKind(input, i)))
{
// The initial state is nullable in this context so at least an empty match exists.
// The last position of the match is i - 1 because the match is empty.
// This value is -1 if i == 0.
return i - 1;
}
// Otherwise, start searching from the current position until the end of the input.
if ((uint)i < (uint)input.Length)
{
SymbolicRegexBuilder<TSetType> builder = currentState.DfaState.Node._builder;
while (true)
{
// If we're at an initial state, try to search ahead for the next possible match location
// using any find optimizations that may have previously been computed.
if (currentState.DfaState is { IsInitialState: true })
{
// i is the most recent position in the input when the dot-star pattern is in the initial state
initialStateIndex = i;
if (_findOpts is RegexFindOptimizations findOpts)
{
// Find the first position i that matches with some likely character.
if (!findOpts.TryFindNextStartingPosition(input, ref i, 0))
{
// no match was found
return NoMatchExists;
}
initialStateIndex = i;
// Update the starting state based on where TryFindNextStartingPosition moved us to.
// As with the initial starting state, if it's a dead end, no match exists.
currentState = new CurrentState(_dotstarredInitialStates[GetCharKind(input, i - 1)]);
if (currentState.DfaState!.IsNothing)
{
return NoMatchExists;
}
}
}
// Now run the DFA or NFA traversal from the current point using the current state. If timeouts are being checked,
// we need to pop out of the inner loop every now and then to do the timeout check in this outer loop.
const int CharsPerTimeoutCheck = 10_000;
ReadOnlySpan<char> inputForInnerLoop = _checkTimeout && input.Length - i > CharsPerTimeoutCheck ?
input.Slice(0, i + CharsPerTimeoutCheck) :
input;
int finalStatePosition;
int findResult = currentState.NfaState is not null ?
FindFinalStatePositionDeltas<NfaStateHandler>(builder, inputForInnerLoop, ref i, ref currentState, ref matchLength, out finalStatePosition) :
FindFinalStatePositionDeltas<DfaStateHandler>(builder, inputForInnerLoop, ref i, ref currentState, ref matchLength, out finalStatePosition);
// If we reached a final or deadend state, we're done.
if (findResult > 0)
{
return finalStatePosition;
}
// We're not at an end state, so we either ran out of input (in which case no match exists), hit an initial state (in which case
// we want to loop around to apply our initial state processing logic and optimizations), or failed to transition (which should
// only happen if we were in DFA mode and need to switch over to NFA mode). If we exited because we hit an initial state,
// find result will be 0, otherwise negative.
if (findResult < 0)
{
if (i >= input.Length)
{
// We ran out of input. No match.
break;
}
if (i < inputForInnerLoop.Length)
{
// We failed to transition. Upgrade to DFA mode.
Debug.Assert(currentState.DfaState is not null);
NfaMatchingState nfaState = perThreadData.NfaState;
nfaState.InitializeFrom(currentState.DfaState);
currentState = new CurrentState(nfaState);
}
}
// Check for a timeout before continuing.
if (_checkTimeout)
{
DoCheckTimeout(timeoutOccursAt);
}
}
}
// No match was found.
return NoMatchExists;
}
/// <summary>
/// Workhorse inner loop for <see cref="FindFinalStatePosition"/>. Consumes the <paramref name="input"/> character by character,
/// starting at <paramref name="i"/>, for each character transitioning from one state in the DFA or NFA graph to the next state,
/// lazily building out the graph as needed.
/// </summary>
/// <remarks>
/// The <typeparamref name="TStateHandler"/> supplies the actual transitioning logic, controlling whether processing is
/// performed in DFA mode or in NFA mode. However, it expects <paramref name="currentState"/> to be configured to match,
/// so for example if <typeparamref name="TStateHandler"/> is a <see cref="DfaStateHandler"/>, it expects the <paramref name="currentState"/>'s
/// <see cref="CurrentState.DfaState"/> to be non-null and its <see cref="CurrentState.NfaState"/> to be null; vice versa for
/// <see cref="NfaStateHandler"/>.
/// </remarks>
/// <returns>
/// A positive value if iteration completed because it reached a nullable or deadend state.
/// 0 if iteration completed because we reached an initial state.
/// A negative value if iteration completed because we ran out of input or we failed to transition.
/// </returns>
private int FindFinalStatePositionDeltas<TStateHandler>(SymbolicRegexBuilder<TSetType> builder, ReadOnlySpan<char> input, ref int i, ref CurrentState currentState, ref int matchLength, out int finalStatePosition)
where TStateHandler : struct, IStateHandler
{
// To avoid frequent reads/writes to ref values, make and operate on local copies, which we then copy back once before returning.
int pos = i;
CurrentState state = currentState;
// Loop through each character in the input, transitioning from state to state for each.
while ((uint)pos < (uint)input.Length && TryTakeTransition<TStateHandler>(builder, input, pos, ref state))
{
// We successfully transitioned for the character at index i. If the new state is nullable for
// the next character, meaning it accepts the empty string, we found a final state and are done!
if (TStateHandler.IsNullable(ref state, GetCharKind(input, pos + 1)))
{
// Check whether there's a fixed-length marker for the current state. If there is, we can
// use that length to optimize subsequent matching phases.
matchLength = TStateHandler.FixedLength(ref state);
currentState = state;
i = pos;
finalStatePosition = pos;
return 1;
}
// If the new state is a dead end, such that we didn't match and we can't transition anywhere
// else, then no match exists.
if (TStateHandler.IsDeadend(ref state))
{
currentState = state;
i = pos;
finalStatePosition = NoMatchExists;
return 1;
}
// We successfully transitioned, so update our current input index to match.
pos++;
// Now that currentState and our position are coherent, check if currentState represents an initial state.
// If it does, we exit out in order to allow our find optimizations to kick in to hopefully more quickly
// find the next possible starting location.
if (TStateHandler.IsInitialState(ref state))
{
currentState = state;
i = pos;
finalStatePosition = 0;
return 0;
}
}
currentState = state;
i = pos;
finalStatePosition = 0;
return -1;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private uint GetCharKind(ReadOnlySpan<char> input, int i)
{
return !_pattern._info.ContainsSomeAnchor ?
CharKind.General : // The previous character kind is irrelevant when anchors are not used.
GetCharKindWithAnchor(input, i);
uint GetCharKindWithAnchor(ReadOnlySpan<char> input, int i)
{
Debug.Assert(_asciiCharKinds is not null);
if ((uint)i >= (uint)input.Length)
{
return CharKind.BeginningEnd;
}
char nextChar = input[i];
if (nextChar == '\n')
{
return
_builder._newLinePredicate.Equals(_builder._solver.False) ? 0 : // ignore \n
i == 0 || i == input.Length - 1 ? CharKind.NewLineS : // very first or very last \n. Detection of very first \n is needed for rev(\Z).
CharKind.Newline;
}
uint[] asciiCharKinds = _asciiCharKinds;
return
nextChar < (uint)asciiCharKinds.Length ? asciiCharKinds[nextChar] :
_builder._solver.And(GetMinterm(nextChar), _builder._wordLetterPredicateForAnchors).Equals(_builder._solver.False) ? 0 : //apply the wordletter predicate to compute the kind of the next character
CharKind.WordLetter;
}
}
/// <summary>Stores additional data for tracking capture start and end positions.</summary>
/// <remarks>The NFA simulation based third phase has one of these for each current state in the current set of live states.</remarks>
internal struct Registers
{
public Registers(int[] captureStarts, int[] captureEnds)
{
CaptureStarts = captureStarts;
CaptureEnds = captureEnds;
}
public int[] CaptureStarts { get; set; }
public int[] CaptureEnds { get; set; }
/// <summary>
/// Applies a list of effects in order to these registers at the provided input position. The order of effects
/// should not matter though, as multiple effects to the same capture start or end do not arise.
/// </summary>
/// <param name="effects">list of effects to be applied</param>
/// <param name="pos">the current input position to record</param>
public void ApplyEffects(DerivativeEffect[] effects, int pos)
{
foreach (DerivativeEffect effect in effects)
{
ApplyEffect(effect, pos);
}
}
/// <summary>
/// Apply a single effect to these registers at the provided input position.
/// </summary>
/// <param name="effect">the effecto to be applied</param>
/// <param name="pos">the current input position to record</param>
public void ApplyEffect(DerivativeEffect effect, int pos)
{
switch (effect.Kind)
{
case DerivativeEffectKind.CaptureStart:
CaptureStarts[effect.CaptureNumber] = pos;
break;
case DerivativeEffectKind.CaptureEnd:
CaptureEnds[effect.CaptureNumber] = pos;
break;
}
}
/// <summary>
/// Make a copy of this set of registers.
/// </summary>
/// <returns>Registers pointing to copies of this set of registers</returns>
public Registers Clone() => new Registers((int[])CaptureStarts.Clone(), (int[])CaptureEnds.Clone());
/// <summary>
/// Copy register values from another set of registers, possibly allocating new arrays if they were not yet allocated.
/// </summary>
/// <param name="other">the registers to copy from</param>
public void Assign(Registers other)
{
if (CaptureStarts is not null && CaptureEnds is not null)
{
Debug.Assert(CaptureStarts.Length == other.CaptureStarts.Length);
Debug.Assert(CaptureEnds.Length == other.CaptureEnds.Length);
Array.Copy(other.CaptureStarts, CaptureStarts, CaptureStarts.Length);
Array.Copy(other.CaptureEnds, CaptureEnds, CaptureEnds.Length);
}
else
{
CaptureStarts = (int[])other.CaptureStarts.Clone();
CaptureEnds = (int[])other.CaptureEnds.Clone();
}
}
}
/// <summary>
/// Per thread data to be held by the regex runner and passed into every call to FindMatch. This is used to
/// avoid repeated memory allocation.
/// </summary>
internal sealed class PerThreadData
{
public readonly NfaMatchingState NfaState;
/// <summary>Maps used for the capturing third phase.</summary>
public readonly SparseIntMap<Registers>? Current, Next;
/// <summary>Registers used for the capturing third phase.</summary>
public readonly Registers InitialRegisters;
public PerThreadData(SymbolicRegexBuilder<TSetType> builder, int capsize)
{
NfaState = new NfaMatchingState(builder);
// Only create data used for capturing mode if there are subcaptures
if (capsize > 1)
{
Current = new();
Next = new();
InitialRegisters = new Registers(new int[capsize], new int[capsize]);
}
}
}
/// <summary>Stores the state that represents a current state in NFA mode.</summary>
/// <remarks>The entire state is composed of a list of individual states.</remarks>
internal sealed class NfaMatchingState
{
/// <summary>The associated builder used to lazily add new DFA or NFA nodes to the graph.</summary>
public readonly SymbolicRegexBuilder<TSetType> Builder;
/// <summary>Ordered set used to store the current NFA states.</summary>
/// <remarks>The value is unused. The type is used purely for its keys.</remarks>
public SparseIntMap<int> NfaStateSet = new();
/// <summary>Scratch set to swap with <see cref="NfaStateSet"/> on each transition.</summary>
/// <remarks>
/// On each transition, <see cref="NfaStateSetScratch"/> is cleared and filled with the next
/// states computed from the current states in <see cref="NfaStateSet"/>, and then the sets
/// are swapped so the scratch becomes the current and the current becomes the scratch.
/// </remarks>
public SparseIntMap<int> NfaStateSetScratch = new();
/// <summary>Create the instance.</summary>
/// <remarks>New instances should only be created once per runner.</remarks>
public NfaMatchingState(SymbolicRegexBuilder<TSetType> builder) => Builder = builder;
/// <summary>Resets this NFA state to represent the supplied DFA state.</summary>
/// <param name="dfaMatchingState">The DFA state to use to initialize the NFA state.</param>
public void InitializeFrom(DfaMatchingState<TSetType> dfaMatchingState)
{
NfaStateSet.Clear();
// If the DFA state is a union of multiple DFA states, loop through all of them
// adding an NFA state for each.
if (dfaMatchingState.Node.Kind is SymbolicRegexNodeKind.Or)
{
Debug.Assert(dfaMatchingState.Node._alts is not null);
foreach (SymbolicRegexNode<TSetType> node in dfaMatchingState.Node._alts)
{
// Create (possibly new) NFA states for all the members.
// Add their IDs to the current set of NFA states and into the list.
int nfaState = Builder.CreateNfaState(node, dfaMatchingState.PrevCharKind);
NfaStateSet.Add(nfaState, out _);
}
}
else
{
// Otherwise, just add an NFA state for the singular DFA state.
SymbolicRegexNode<TSetType> node = dfaMatchingState.Node;
int nfaState = Builder.CreateNfaState(node, dfaMatchingState.PrevCharKind);
NfaStateSet.Add(nfaState, out _);
}
}
}
/// <summary>Represents a current state in a DFA or NFA graph walk while processing a regular expression.</summary>
/// <remarks>This is a discriminated union between a DFA state and an NFA state. One and only one will be non-null.</remarks>
private struct CurrentState
{
/// <summary>Initializes the state as a DFA state.</summary>
public CurrentState(DfaMatchingState<TSetType> dfaState)
{
DfaState = dfaState;
NfaState = null;
}
/// <summary>Initializes the state as an NFA state.</summary>
public CurrentState(NfaMatchingState nfaState)
{
DfaState = null;
NfaState = nfaState;
}
/// <summary>The DFA state.</summary>
public DfaMatchingState<TSetType>? DfaState;
/// <summary>The NFA state.</summary>
public NfaMatchingState? NfaState;
}
/// <summary>Represents a set of routines for operating over a <see cref="CurrentState"/>.</summary>
private interface IStateHandler
{
#pragma warning disable CA2252 // This API requires opting into preview features
public static abstract bool StartsWithLineAnchor(ref CurrentState state);
public static abstract bool IsNullable(ref CurrentState state, uint nextCharKind);
public static abstract bool IsDeadend(ref CurrentState state);
public static abstract int FixedLength(ref CurrentState state);
public static abstract bool IsInitialState(ref CurrentState state);
public static abstract bool TakeTransition(SymbolicRegexBuilder<TSetType> builder, ref CurrentState state, int mintermId);
#pragma warning restore CA2252 // This API requires opting into preview features
}
/// <summary>An <see cref="IStateHandler"/> for operating over <see cref="CurrentState"/> instances configured as DFA states.</summary>
private readonly struct DfaStateHandler : IStateHandler
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool StartsWithLineAnchor(ref CurrentState state) => state.DfaState!.StartsWithLineAnchor;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool IsNullable(ref CurrentState state, uint nextCharKind) => state.DfaState!.IsNullable(nextCharKind);
/// <summary>Gets whether this is a dead-end state, meaning there are no transitions possible out of the state.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool IsDeadend(ref CurrentState state) => state.DfaState!.IsDeadend;
/// <summary>Gets the length of any fixed-length marker that exists for this state, or -1 if there is none.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int FixedLength(ref CurrentState state) => state.DfaState!.FixedLength;
/// <summary>Gets whether this is an initial state.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool IsInitialState(ref CurrentState state) => state.DfaState!.IsInitialState;
/// <summary>Take the transition to the next DFA state.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool TakeTransition(SymbolicRegexBuilder<TSetType> builder, ref CurrentState state, int mintermId)
{
Debug.Assert(state.DfaState is not null, $"Expected non-null {nameof(state.DfaState)}.");
Debug.Assert(state.NfaState is null, $"Expected null {nameof(state.NfaState)}.");
Debug.Assert(builder._delta is not null);
// Get the current state.
DfaMatchingState<TSetType> dfaMatchingState = state.DfaState!;
// Use the mintermId for the character being read to look up which state to transition to.
// If that state has already been materialized, move to it, and we're done. If that state
// hasn't been materialized, try to create it; if we can, move to it, and we're done.
int dfaOffset = (dfaMatchingState.Id << builder._mintermsLog) | mintermId;
DfaMatchingState<TSetType>? nextState = builder._delta[dfaOffset];
if (nextState is not null || builder.TryCreateNewTransition(dfaMatchingState, mintermId, dfaOffset, checkThreshold: true, out nextState))
{
// There was an existing state for this transition or we were able to create one. Move to it and
// return that we're still operating as a DFA and can keep going.
state.DfaState = nextState;
return true;
}
return false;
}
}
/// <summary>An <see cref="IStateHandler"/> for operating over <see cref="CurrentState"/> instances configured as NFA states.</summary>
private readonly struct NfaStateHandler : IStateHandler
{
/// <summary>Check if any underlying core state starts with a line anchor.</summary>
public static bool StartsWithLineAnchor(ref CurrentState state)
{
SymbolicRegexBuilder<TSetType> builder = state.NfaState!.Builder;
foreach (ref KeyValuePair<int, int> nfaState in CollectionsMarshal.AsSpan(state.NfaState!.NfaStateSet.Values))
{
if (builder.GetCoreState(nfaState.Key).StartsWithLineAnchor)
{
return true;
}
}
return false;
}
/// <summary>Check if any underlying core state is nullable.</summary>
public static bool IsNullable(ref CurrentState state, uint nextCharKind)
{
SymbolicRegexBuilder<TSetType> builder = state.NfaState!.Builder;
foreach (ref KeyValuePair<int, int> nfaState in CollectionsMarshal.AsSpan(state.NfaState!.NfaStateSet.Values))
{
if (builder.GetCoreState(nfaState.Key).IsNullable(nextCharKind))
{
return true;
}
}
return false;
}
/// <summary>Gets whether this is a dead-end state, meaning there are no transitions possible out of the state.</summary>
/// <remarks>In NFA mode, an empty set of states means that it is a dead end.</remarks>
public static bool IsDeadend(ref CurrentState state) => state.NfaState!.NfaStateSet.Count == 0;
/// <summary>Gets the length of any fixed-length marker that exists for this state, or -1 if there is none.</summary>
/// <summary>In NFA mode, there are no fixed-length markers.</summary>
public static int FixedLength(ref CurrentState state) => -1;
/// <summary>Gets whether this is an initial state.</summary>
/// <summary>In NFA mode, no set of states qualifies as an initial state.</summary>
public static bool IsInitialState(ref CurrentState state) => false;
/// <summary>Take the transition to the next NFA state.</summary>
public static bool TakeTransition(SymbolicRegexBuilder<TSetType> builder, ref CurrentState state, int mintermId)
{
Debug.Assert(state.DfaState is null, $"Expected null {nameof(state.DfaState)}.");
Debug.Assert(state.NfaState is not null, $"Expected non-null {nameof(state.NfaState)}.");
NfaMatchingState nfaState = state.NfaState!;
// Grab the sets, swapping the current active states set with the scratch set.
SparseIntMap<int> nextStates = nfaState.NfaStateSetScratch;
SparseIntMap<int> sourceStates = nfaState.NfaStateSet;
nfaState.NfaStateSet = nextStates;
nfaState.NfaStateSetScratch = sourceStates;
// Compute the set of all unique next states from the current source states and the mintermId.
nextStates.Clear();
if (sourceStates.Count == 1)
{
// We have a single source state. We know its next states are already deduped,
// so we can just add them directly to the destination states list.
foreach (int nextState in GetNextStates(sourceStates.Values[0].Key, mintermId, builder))
{
nextStates.Add(nextState, out _);
}
}
else
{
// We have multiple source states, so we need to potentially dedup across each of
// their next states. For each source state, get its next states, adding each into
// our set (which exists purely for deduping purposes), and if we successfully added
// to the set, then add the known-unique state to the destination list.
foreach (ref KeyValuePair<int, int> sourceState in CollectionsMarshal.AsSpan(sourceStates.Values))
{
foreach (int nextState in GetNextStates(sourceState.Key, mintermId, builder))
{
nextStates.Add(nextState, out _);
}
}
}
return true;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static int[] GetNextStates(int sourceState, int mintermId, SymbolicRegexBuilder<TSetType> builder)
{
// Calculate the offset into the NFA transition table.
int nfaOffset = (sourceState << builder._mintermsLog) | mintermId;
// Get the next NFA state.
return builder._nfaDelta[nfaOffset] ?? builder.CreateNewNfaTransition(sourceState, mintermId, nfaOffset);
}
}
}
#if DEBUG
public override void SaveDGML(TextWriter writer, int bound, bool hideStateInfo, bool addDotStar, bool inReverse, bool onlyDFAinfo, int maxLabelLength, bool asNFA)
{
var graph = new DGML.RegexAutomaton<TSetType>(this, bound, addDotStar, inReverse, asNFA);
var dgml = new DGML.DgmlWriter(writer, hideStateInfo, maxLabelLength, onlyDFAinfo);
dgml.Write(graph);
}
public override IEnumerable<string> GenerateRandomMembers(int k, int randomseed, bool negative) =>
new SymbolicRegexSampler<TSetType>(_pattern, randomseed, negative).GenerateRandomMembers(k);
#endif
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;
namespace System.Text.RegularExpressions.Symbolic
{
/// <summary>Represents a regex matching engine that performs regex matching using symbolic derivatives.</summary>
internal abstract class SymbolicRegexMatcher
{
#if DEBUG
/// <summary>Unwind the regex of the matcher and save the resulting state graph in DGML</summary>
/// <param name="writer">Writer to which the DGML is written.</param>
/// <param name="nfa">True to create an NFA instead of a DFA.</param>
/// <param name="addDotStar">True to prepend .*? onto the pattern (outside of the implicit root capture).</param>
/// <param name="reverse">If true, then unwind the regex backwards.</param>
/// <param name="maxStates">The approximate maximum number of states to include; less than or equal to 0 for no maximum.</param>
/// <param name="maxLabelLength">maximum length of labels in nodes anything over that length is indicated with .. </param>
public abstract void SaveDGML(TextWriter writer, bool nfa, bool addDotStar, bool reverse, int maxStates, int maxLabelLength);
/// <summary>
/// Generates up to k random strings matched by the regex
/// </summary>
/// <param name="k">upper bound on the number of generated strings</param>
/// <param name="randomseed">random seed for the generator, 0 means no random seed</param>
/// <param name="negative">if true then generate inputs that do not match</param>
/// <returns></returns>
public abstract IEnumerable<string> GenerateRandomMembers(int k, int randomseed, bool negative);
#endif
}
/// <summary>Represents a regex matching engine that performs regex matching using symbolic derivatives.</summary>
/// <typeparam name="TSetType">Character set type.</typeparam>
internal sealed class SymbolicRegexMatcher<TSetType> : SymbolicRegexMatcher where TSetType : notnull
{
/// <summary>Maximum number of built states before switching over to NFA mode.</summary>
/// <remarks>
/// By default, all matching starts out using DFAs, where every state transitions to one and only one
/// state for any minterm (each character maps to one minterm). Some regular expressions, however, can result
/// in really, really large DFA state graphs, much too big to actually store. Instead of failing when we
/// encounter such state graphs, at some point we instead switch from processing as a DFA to processing as
/// an NFA. As an NFA, we instead track all of the states we're in at any given point, and transitioning
/// from one "state" to the next really means for every constituent state that composes our current "state",
/// we find all possible states that transitioning out of each of them could result in, and the union of
/// all of those is our new "state". This constant represents the size of the graph after which we start
/// processing as an NFA instead of as a DFA. This processing doesn't change immediately, however. All
/// processing starts out in DFA mode, even if we've previously triggered NFA mode for the same regex.
/// We switch over into NFA mode the first time a given traversal (match operation) results in us needing
/// to create a new node and the graph is already or newly beyond this threshold.
/// </remarks>
internal const int NfaThreshold = 10_000;
/// <summary>Sentinel value used internally by the matcher to indicate no match exists.</summary>
private const int NoMatchExists = -2;
/// <summary>Builder used to create <see cref="SymbolicRegexNode{S}"/>s while matching.</summary>
/// <remarks>
/// The builder is used to build up the DFA state space lazily, which means we need to be able to
/// produce new <see cref="SymbolicRegexNode{S}"/>s as we match. Once in NFA mode, we also use
/// the builder to produce new NFA states. The builder maintains a cache of all DFA and NFA states.
/// </remarks>
internal readonly SymbolicRegexBuilder<TSetType> _builder;
/// <summary>Maps every character to its corresponding minterm ID.</summary>
private readonly MintermClassifier _mintermClassifier;
/// <summary><see cref="_pattern"/> prefixed with [0-0xFFFF]*</summary>
/// <remarks>
/// The matching engine first uses <see cref="_dotStarredPattern"/> to find whether there is a match
/// and where that match might end. Prepending the .* prefix onto the original pattern provides the DFA
/// with the ability to continue to process input characters even if those characters aren't part of
/// the match. If Regex.IsMatch is used, nothing further is needed beyond this prefixed pattern. If, however,
/// other matching operations are performed that require knowing the exact start and end of the match,
/// the engine then needs to process the pattern in reverse to find where the match actually started;
/// for that, it uses the <see cref="_reversePattern"/> and walks backwards through the input characters
/// from where <see cref="_dotStarredPattern"/> left off. At this point we know that there was a match,
/// where it started, and where it could have ended, but that ending point could be influenced by the
/// selection of the starting point. So, to find the actual ending point, the original <see cref="_pattern"/>
/// is then used from that starting point to walk forward through the input characters again to find the
/// actual end point used for the match.
/// </remarks>
internal readonly SymbolicRegexNode<TSetType> _dotStarredPattern;
/// <summary>The original regex pattern.</summary>
internal readonly SymbolicRegexNode<TSetType> _pattern;
/// <summary>The reverse of <see cref="_pattern"/>.</summary>
/// <remarks>
/// Determining that there is a match and where the match ends requires only <see cref="_pattern"/>.
/// But from there determining where the match began requires reversing the pattern and running
/// the matcher again, starting from the ending position. This <see cref="_reversePattern"/> caches
/// that reversed pattern used for extracting match start.
/// </remarks>
internal readonly SymbolicRegexNode<TSetType> _reversePattern;
/// <summary>true iff timeout checking is enabled.</summary>
private readonly bool _checkTimeout;
/// <summary>Timeout in milliseconds. This is only used if <see cref="_checkTimeout"/> is true.</summary>
private readonly int _timeout;
/// <summary>Data and routines for skipping ahead to the next place a match could potentially start.</summary>
private readonly RegexFindOptimizations? _findOpts;
/// <summary>The initial states for the original pattern, keyed off of the previous character kind.</summary>
/// <remarks>If the pattern doesn't contain any anchors, there will only be a single initial state.</remarks>
private readonly DfaMatchingState<TSetType>[] _initialStates;
/// <summary>The initial states for the dot-star pattern, keyed off of the previous character kind.</summary>
/// <remarks>If the pattern doesn't contain any anchors, there will only be a single initial state.</remarks>
private readonly DfaMatchingState<TSetType>[] _dotstarredInitialStates;
/// <summary>The initial states for the reverse pattern, keyed off of the previous character kind.</summary>
/// <remarks>If the pattern doesn't contain any anchors, there will only be a single initial state.</remarks>
private readonly DfaMatchingState<TSetType>[] _reverseInitialStates;
/// <summary>Lookup table to quickly determine the character kind for ASCII characters.</summary>
/// <remarks>Non-null iff the pattern contains anchors; otherwise, it's unused.</remarks>
private readonly uint[]? _asciiCharKinds;
/// <summary>Number of capture groups.</summary>
private readonly int _capsize;
/// <summary>Fixed-length of any possible match.</summary>
/// <remarks>This will be null if matches may be of varying lengths or if a fixed-length couldn't otherwise be computed.</remarks>
private readonly int? _fixedMatchLength;
/// <summary>Gets whether the regular expression contains captures (beyond the implicit root-level capture).</summary>
/// <remarks>This determines whether the matcher uses the special capturing NFA simulation mode.</remarks>
internal bool HasSubcaptures => _capsize > 1;
/// <summary>Get the minterm of <paramref name="c"/>.</summary>
/// <param name="c">character code</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private TSetType GetMinterm(int c)
{
Debug.Assert(_builder._minterms is not null);
return _builder._minterms[_mintermClassifier.GetMintermID(c)];
}
/// <summary>Constructs matcher for given symbolic regex.</summary>
internal SymbolicRegexMatcher(SymbolicRegexNode<TSetType> sr, RegexTree regexTree, BDD[] minterms, TimeSpan matchTimeout)
{
Debug.Assert(sr._builder._solver is BitVector64Algebra or BitVectorAlgebra or CharSetSolver, $"Unsupported algebra: {sr._builder._solver}");
_pattern = sr;
_builder = sr._builder;
_checkTimeout = Regex.InfiniteMatchTimeout != matchTimeout;
_timeout = (int)(matchTimeout.TotalMilliseconds + 0.5); // Round up, so it will be at least 1ms
_mintermClassifier = _builder._solver switch
{
BitVector64Algebra bv64 => bv64._classifier,
BitVectorAlgebra bv => bv._classifier,
_ => new MintermClassifier((CharSetSolver)(object)_builder._solver, minterms),
};
_capsize = regexTree.CaptureCount;
if (regexTree.FindOptimizations.MinRequiredLength == regexTree.FindOptimizations.MaxPossibleLength)
{
_fixedMatchLength = regexTree.FindOptimizations.MinRequiredLength;
}
if (regexTree.FindOptimizations.FindMode != FindNextStartingPositionMode.NoSearch &&
regexTree.FindOptimizations.LeadingAnchor == 0) // If there are any anchors, we're better off letting the DFA quickly do its job of determining whether there's a match.
{
_findOpts = regexTree.FindOptimizations;
}
// Determine the number of initial states. If there's no anchor, only the default previous
// character kind 0 is ever going to be used for all initial states.
int statesCount = _pattern._info.ContainsSomeAnchor ? CharKind.CharKindCount : 1;
// Create the initial states for the original pattern.
var initialStates = new DfaMatchingState<TSetType>[statesCount];
for (uint i = 0; i < initialStates.Length; i++)
{
initialStates[i] = _builder.CreateState(_pattern, i, capturing: HasSubcaptures);
}
_initialStates = initialStates;
// Create the dot-star pattern (a concatenation of any* with the original pattern)
// and all of its initial states.
_dotStarredPattern = _builder.CreateConcat(_builder._anyStar, _pattern);
var dotstarredInitialStates = new DfaMatchingState<TSetType>[statesCount];
for (uint i = 0; i < dotstarredInitialStates.Length; i++)
{
// Used to detect if initial state was reentered,
// but observe that the behavior from the state may ultimately depend on the previous
// input char e.g. possibly causing nullability of \b or \B or of a start-of-line anchor,
// in that sense there can be several "versions" (not more than StateCount) of the initial state.
DfaMatchingState<TSetType> state = _builder.CreateState(_dotStarredPattern, i, capturing: false);
state.IsInitialState = true;
dotstarredInitialStates[i] = state;
}
_dotstarredInitialStates = dotstarredInitialStates;
// Create the reverse pattern (the original pattern in reverse order) and all of its
// initial states. Also disable backtracking simulation to ensure the reverse path from
// the final state that was found is followed. Not doing so might cause the earliest
// starting point to not be found.
_reversePattern = _builder.CreateDisableBacktrackingSimulation(_pattern.Reverse());
var reverseInitialStates = new DfaMatchingState<TSetType>[statesCount];
for (uint i = 0; i < reverseInitialStates.Length; i++)
{
reverseInitialStates[i] = _builder.CreateState(_reversePattern, i, capturing: false);
}
_reverseInitialStates = reverseInitialStates;
// Initialize our fast-lookup for determining the character kind of ASCII characters.
// This is only required when the pattern contains anchors, as otherwise there's only
// ever a single kind used.
if (_pattern._info.ContainsSomeAnchor)
{
var asciiCharKinds = new uint[128];
for (int i = 0; i < asciiCharKinds.Length; i++)
{
TSetType predicate2;
uint charKind;
if (i == '\n')
{
predicate2 = _builder._newLinePredicate;
charKind = CharKind.Newline;
}
else
{
predicate2 = _builder._wordLetterPredicateForAnchors;
charKind = CharKind.WordLetter;
}
asciiCharKinds[i] = _builder._solver.And(GetMinterm(i), predicate2).Equals(_builder._solver.False) ? 0 : charKind;
}
_asciiCharKinds = asciiCharKinds;
}
}
/// <summary>
/// Create a PerThreadData with the appropriate parts initialized for this matcher's pattern.
/// </summary>
internal PerThreadData CreatePerThreadData() => new PerThreadData(_builder, _capsize);
/// <summary>Compute the target state for the source state and input[i] character and transition to it.</summary>
/// <param name="builder">The associated builder.</param>
/// <param name="input">The input text.</param>
/// <param name="i">The index into <paramref name="input"/> at which the target character lives.</param>
/// <param name="state">The current state being transitioned from. Upon return it's the new state if the transition succeeded.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private bool TryTakeTransition<TStateHandler>(SymbolicRegexBuilder<TSetType> builder, ReadOnlySpan<char> input, int i, ref CurrentState state)
where TStateHandler : struct, IStateHandler
{
int c = input[i];
int mintermId = c == '\n' && i == input.Length - 1 && TStateHandler.StartsWithLineAnchor(ref state) ?
builder._minterms!.Length : // mintermId = minterms.Length represents \Z (last \n)
_mintermClassifier.GetMintermID(c);
return TStateHandler.TakeTransition(builder, ref state, mintermId);
}
private List<(DfaMatchingState<TSetType>, DerivativeEffect[])> CreateNewCapturingTransitions(DfaMatchingState<TSetType> state, TSetType minterm, int offset)
{
Debug.Assert(_builder._capturingDelta is not null);
lock (this)
{
// Get the next state if it exists. The caller should have already tried and found it null (not yet created),
// but in the interim another thread could have created it.
List<(DfaMatchingState<TSetType>, DerivativeEffect[])>? p = _builder._capturingDelta[offset];
if (p is null)
{
// Build the new state and store it into the array.
p = state.NfaNextWithEffects(minterm);
Volatile.Write(ref _builder._capturingDelta[offset], p);
}
return p;
}
}
private void DoCheckTimeout(int timeoutOccursAt)
{
// This logic is identical to RegexRunner.DoCheckTimeout, with the exception of check skipping. RegexRunner calls
// DoCheckTimeout potentially on every iteration of a loop, whereas this calls it only once per transition.
int currentMillis = Environment.TickCount;
if (currentMillis >= timeoutOccursAt && (0 <= timeoutOccursAt || 0 >= currentMillis))
{
throw new RegexMatchTimeoutException(string.Empty, string.Empty, TimeSpan.FromMilliseconds(_timeout));
}
}
/// <summary>Find a match.</summary>
/// <param name="isMatch">Whether to return once we know there's a match without determining where exactly it matched.</param>
/// <param name="input">The input span</param>
/// <param name="startat">The position to start search in the input span.</param>
/// <param name="perThreadData">Per thread data reused between calls.</param>
public SymbolicMatch FindMatch(bool isMatch, ReadOnlySpan<char> input, int startat, PerThreadData perThreadData)
{
Debug.Assert(startat >= 0 && startat <= input.Length, $"{nameof(startat)} == {startat}, {nameof(input.Length)} == {input.Length}");
Debug.Assert(perThreadData is not null);
// If we need to perform timeout checks, store the absolute timeout value.
int timeoutOccursAt = 0;
if (_checkTimeout)
{
// Using Environment.TickCount for efficiency instead of Stopwatch -- as in the non-DFA case.
timeoutOccursAt = Environment.TickCount + (int)(_timeout + 0.5);
}
// If we're starting at the end of the input, we don't need to do any work other than
// determine whether an empty match is valid, i.e. whether the pattern is "nullable"
// given the kinds of characters at and just before the end.
if (startat == input.Length)
{
// TODO https://github.com/dotnet/runtime/issues/65606: Handle capture groups.
uint prevKind = GetCharKind(input, startat - 1);
uint nextKind = GetCharKind(input, startat);
return _pattern.IsNullableFor(CharKind.Context(prevKind, nextKind)) ?
new SymbolicMatch(startat, 0) :
SymbolicMatch.NoMatch;
}
// Phase 1:
// Determine whether there is a match by finding the first final state position. This only tells
// us whether there is a match but needn't give us the longest possible match. This may return -1 as
// a legitimate value when the initial state is nullable and startat == 0. It returns NoMatchExists (-2)
// when there is no match. As an example, consider the pattern a{5,10}b* run against an input
// of aaaaaaaaaaaaaaabbbc: phase 1 will find the position of the first b: aaaaaaaaaaaaaaab.
int i = FindFinalStatePosition(input, startat, timeoutOccursAt, out int matchStartLowBoundary, out int matchStartLengthMarker, perThreadData);
// If there wasn't a match, we're done.
if (i == NoMatchExists)
{
return SymbolicMatch.NoMatch;
}
// A match exists. If we don't need further details, because IsMatch was used (and thus we don't
// need the exact bounds of the match, captures, etc.), we're done.
if (isMatch)
{
return SymbolicMatch.QuickMatch;
}
// Phase 2:
// Match backwards through the input matching against the reverse of the pattern, looking for the earliest
// start position. That tells us the actual starting position of the match. We can skip this phase if we
// recorded a fixed-length marker for the portion of the pattern that matched, as we can then jump that
// exact number of positions backwards. Continuing the previous example, phase 2 will walk backwards from
// that first b until it finds the 6th a: aaaaaaaaaab.
int matchStart;
if (matchStartLengthMarker >= 0)
{
matchStart = i - matchStartLengthMarker + 1;
}
else
{
Debug.Assert(i >= startat - 1);
matchStart = i < startat ?
startat :
FindStartPosition(input, i, matchStartLowBoundary, perThreadData);
}
// Phase 3:
// Match again, this time from the computed start position, to find the latest end position. That start
// and end then represent the bounds of the match. If the pattern has subcaptures (captures other than
// the top-level capture for the whole match), we need to do more work to compute their exact bounds, so we
// take a faster path if captures aren't required. Further, if captures aren't needed, and if any possible
// match of the whole pattern is a fixed length, we can skip this phase as well, just using that fixed-length
// to compute the ending position based on the starting position. Continuing the previous example, phase 3
// will walk forwards from the 6th a until it finds the end of the match: aaaaaaaaaabbb.
if (!HasSubcaptures)
{
if (_fixedMatchLength.HasValue)
{
return new SymbolicMatch(matchStart, _fixedMatchLength.GetValueOrDefault());
}
int matchEnd = FindEndPosition(input, matchStart, perThreadData);
return new SymbolicMatch(matchStart, matchEnd + 1 - matchStart);
}
else
{
int matchEnd = FindEndPositionCapturing(input, matchStart, out Registers endRegisters, perThreadData);
return new SymbolicMatch(matchStart, matchEnd + 1 - matchStart, endRegisters.CaptureStarts, endRegisters.CaptureEnds);
}
}
/// <summary>Phase 3 of matching. From a found starting position, find the ending position of the match using the original pattern.</summary>
/// <remarks>
/// The ending position is known to exist; this function just needs to determine exactly what it is.
/// We need to find the longest possible match and thus the latest valid ending position.
/// </remarks>
/// <param name="input">The input text.</param>
/// <param name="i">The starting position of the match.</param>
/// <param name="perThreadData">Per thread data reused between calls.</param>
/// <returns>The found ending position of the match.</returns>
private int FindEndPosition(ReadOnlySpan<char> input, int i, PerThreadData perThreadData)
{
// Get the starting state based on the current context.
DfaMatchingState<TSetType> dfaStartState = _initialStates[GetCharKind(input, i - 1)];
// If the starting state is nullable (accepts the empty string), then it's a valid
// match and we need to record the position as a possible end, but keep going looking
// for a better one.
int end = input.Length; // invalid sentinel value
if (dfaStartState.IsNullable(GetCharKind(input, i)))
{
// Empty match exists because the initial state is accepting.
end = i - 1;
}
if ((uint)i < (uint)input.Length)
{
// Iterate from the starting state until we've found the best ending state.
SymbolicRegexBuilder<TSetType> builder = dfaStartState.Node._builder;
var currentState = new CurrentState(dfaStartState);
while (true)
{
// Run the DFA or NFA traversal backwards from the current point using the current state.
bool done = currentState.NfaState is not null ?
FindEndPositionDeltas<NfaStateHandler>(builder, input, ref i, ref currentState, ref end) :
FindEndPositionDeltas<DfaStateHandler>(builder, input, ref i, ref currentState, ref end);
// If we successfully found the ending position, we're done.
if (done || (uint)i >= (uint)input.Length)
{
break;
}
// We exited out of the inner processing loop, but we didn't hit a dead end or run out
// of input, and that should only happen if we failed to transition from one state to
// the next, which should only happen if we were in DFA mode and we tried to create
// a new state and exceeded the graph size. Upgrade to NFA mode and continue;
Debug.Assert(currentState.DfaState is not null);
NfaMatchingState nfaState = perThreadData.NfaState;
nfaState.InitializeFrom(currentState.DfaState);
currentState = new CurrentState(nfaState);
}
}
// Return the found ending position.
Debug.Assert(end < input.Length, "Expected to find an ending position but didn't");
return end;
}
/// <summary>
/// Workhorse inner loop for <see cref="FindEndPosition"/>. Consumes the <paramref name="input"/> character by character,
/// starting at <paramref name="i"/>, for each character transitioning from one state in the DFA or NFA graph to the next state,
/// lazily building out the graph as needed.
/// </summary>
private bool FindEndPositionDeltas<TStateHandler>(SymbolicRegexBuilder<TSetType> builder, ReadOnlySpan<char> input, ref int i, ref CurrentState currentState, ref int endingIndex)
where TStateHandler : struct, IStateHandler
{
// To avoid frequent reads/writes to ref values, make and operate on local copies, which we then copy back once before returning.
int pos = i;
CurrentState state = currentState;
// Repeatedly read the next character from the input and use it to transition the current state to the next.
// We're looking for the furthest final state we can find.
while ((uint)pos < (uint)input.Length && TryTakeTransition<TStateHandler>(builder, input, pos, ref state))
{
if (TStateHandler.IsNullable(ref state, GetCharKind(input, pos + 1)))
{
// If the new state accepts the empty string, we found an ending state. Record the position.
endingIndex = pos;
}
else if (TStateHandler.IsDeadend(ref state))
{
// If the new state is a dead end, the match ended the last time endingIndex was updated.
currentState = state;
i = pos;
return true;
}
// We successfully transitioned to the next state and consumed the current character,
// so move along to the next.
pos++;
}
// We either ran out of input, in which case we successfully recorded an ending index,
// or we failed to transition to the next state due to the graph becoming too large.
currentState = state;
i = pos;
return false;
}
/// <summary>Find match end position using the original pattern, end position is known to exist. This version also produces captures.</summary>
/// <param name="input">input span</param>
/// <param name="i">inclusive start position</param>
/// <param name="resultRegisters">out parameter for the final register values, which indicate capture starts and ends</param>
/// <param name="perThreadData">Per thread data reused between calls.</param>
/// <returns>the match end position</returns>
private int FindEndPositionCapturing(ReadOnlySpan<char> input, int i, out Registers resultRegisters, PerThreadData perThreadData)
{
int i_end = input.Length;
Registers endRegisters = default;
DfaMatchingState<TSetType>? endState = null;
// Pick the correct start state based on previous character kind.
DfaMatchingState<TSetType> initialState = _initialStates[GetCharKind(input, i - 1)];
Registers initialRegisters = perThreadData.InitialRegisters;
// Initialize registers with -1, which means "not seen yet"
Array.Fill(initialRegisters.CaptureStarts, -1);
Array.Fill(initialRegisters.CaptureEnds, -1);
if (initialState.IsNullable(GetCharKind(input, i)))
{
// Empty match exists because the initial state is accepting.
i_end = i - 1;
endRegisters.Assign(initialRegisters);
endState = initialState;
}
// Use two maps from state IDs to register values for the current and next set of states.
// Note that these maps use insertion order, which is used to maintain priorities between states in a way
// that matches the order the backtracking engines visit paths.
Debug.Assert(perThreadData.Current is not null && perThreadData.Next is not null);
SparseIntMap<Registers> current = perThreadData.Current, next = perThreadData.Next;
current.Clear();
next.Clear();
current.Add(initialState.Id, initialRegisters);
SymbolicRegexBuilder<TSetType> builder = _builder;
while ((uint)i < (uint)input.Length)
{
Debug.Assert(next.Count == 0);
int c = input[i];
int normalMintermId = _mintermClassifier.GetMintermID(c);
foreach ((int sourceId, Registers sourceRegisters) in current.Values)
{
Debug.Assert(builder._capturingStateArray is not null);
DfaMatchingState<TSetType> sourceState = builder._capturingStateArray[sourceId];
// Find the minterm, handling the special case for the last \n
int mintermId = c == '\n' && i == input.Length - 1 && sourceState.StartsWithLineAnchor ?
builder._minterms!.Length :
normalMintermId; // mintermId = minterms.Length represents \Z (last \n)
TSetType minterm = builder.GetMinterm(mintermId);
// Get or create the transitions
int offset = (sourceId << builder._mintermsLog) | mintermId;
Debug.Assert(builder._capturingDelta is not null);
List<(DfaMatchingState<TSetType>, DerivativeEffect[])>? transitions =
builder._capturingDelta[offset] ??
CreateNewCapturingTransitions(sourceState, minterm, offset);
// Take the transitions in their prioritized order
for (int j = 0; j < transitions.Count; ++j)
{
(DfaMatchingState<TSetType> targetState, DerivativeEffect[] effects) = transitions[j];
if (targetState.IsDeadend)
continue;
// Try to add the state and handle the case where it didn't exist before. If the state already
// exists, then the transition can be safely ignored, as the existing state was generated by a
// higher priority transition.
if (next.Add(targetState.Id, out int index))
{
// Avoid copying the registers on the last transition from this state, reusing the registers instead
Registers newRegisters = j != transitions.Count - 1 ? sourceRegisters.Clone() : sourceRegisters;
newRegisters.ApplyEffects(effects, i);
next.Update(index, targetState.Id, newRegisters);
if (targetState.IsNullable(GetCharKind(input, i + 1)))
{
// Accepting state has been reached. Record the position.
i_end = i;
endRegisters.Assign(newRegisters);
endState = targetState;
// No lower priority transitions from this or other source states are taken because the
// backtracking engines would return the match ending here.
goto BreakNullable;
}
}
}
}
BreakNullable:
if (next.Count == 0)
{
// If all states died out some nullable state must have been seen before
break;
}
// Swap the state sets and prepare for the next character
SparseIntMap<Registers> tmp = current;
current = next;
next = tmp;
next.Clear();
i++;
}
Debug.Assert(i_end != input.Length && endState is not null);
// Apply effects for finishing at the stored end state
endState.Node.ApplyEffects((effect, args) => args.Registers.ApplyEffect(effect, args.Pos),
CharKind.Context(endState.PrevCharKind, GetCharKind(input, i_end + 1)), (Registers: endRegisters, Pos: i_end + 1));
resultRegisters = endRegisters;
return i_end;
}
/// <summary>
/// Phase 2 of matching. From a found ending position, walk in reverse through the input using the reverse pattern to find the
/// start position of match.
/// </summary>
/// <remarks>
/// The start position is known to exist; this function just needs to determine exactly what it is.
/// We need to find the earliest (lowest index) starting position that's not earlier than <paramref name="matchStartBoundary"/>.
/// </remarks>
/// <param name="input">The input text.</param>
/// <param name="i">The ending position to walk backwards from. <paramref name="i"/> points at the last character of the match.</param>
/// <param name="matchStartBoundary">The initial starting location discovered in phase 1, a point we must not walk earlier than.</param>
/// <param name="perThreadData">Per thread data reused between calls.</param>
/// <returns>The found starting position for the match.</returns>
private int FindStartPosition(ReadOnlySpan<char> input, int i, int matchStartBoundary, PerThreadData perThreadData)
{
Debug.Assert(i >= 0, $"{nameof(i)} == {i}");
Debug.Assert(matchStartBoundary >= 0 && matchStartBoundary < input.Length, $"{nameof(matchStartBoundary)} == {matchStartBoundary}");
Debug.Assert(i >= matchStartBoundary, $"Expected {i} >= {matchStartBoundary}.");
// Get the starting state for the reverse pattern. This depends on previous character (which, because we're
// going backwards, is character number i + 1).
var currentState = new CurrentState(_reverseInitialStates[GetCharKind(input, i + 1)]);
// If the initial state is nullable, meaning it accepts the empty string, then we've already discovered
// a valid starting position, and we just need to keep looking for an earlier one in case there is one.
int lastStart = -1; // invalid sentinel value
if (currentState.DfaState!.IsNullable(GetCharKind(input, i)))
{
lastStart = i + 1;
}
// Walk backwards to the furthest accepting state of the reverse pattern but no earlier than matchStartBoundary.
SymbolicRegexBuilder<TSetType> builder = currentState.DfaState.Node._builder;
while (true)
{
// Run the DFA or NFA traversal backwards from the current point using the current state.
bool done = currentState.NfaState is not null ?
FindStartPositionDeltas<NfaStateHandler>(builder, input, ref i, matchStartBoundary, ref currentState, ref lastStart) :
FindStartPositionDeltas<DfaStateHandler>(builder, input, ref i, matchStartBoundary, ref currentState, ref lastStart);
// If we found the starting position, we're done.
if (done)
{
break;
}
// We didn't find the starting position but we did exit out of the backwards traversal. That should only happen
// if we were unable to transition, which should only happen if we were in DFA mode and exceeded our graph size.
// Upgrade to NFA mode and continue.
Debug.Assert(i >= matchStartBoundary);
Debug.Assert(currentState.DfaState is not null);
NfaMatchingState nfaState = perThreadData.NfaState;
nfaState.InitializeFrom(currentState.DfaState);
currentState = new CurrentState(nfaState);
}
Debug.Assert(lastStart != -1, "We expected to find a starting position but didn't.");
return lastStart;
}
/// <summary>
/// Workhorse inner loop for <see cref="FindStartPosition"/>. Consumes the <paramref name="input"/> character by character in reverse,
/// starting at <paramref name="i"/>, for each character transitioning from one state in the DFA or NFA graph to the next state,
/// lazily building out the graph as needed.
/// </summary>
private bool FindStartPositionDeltas<TStateHandler>(SymbolicRegexBuilder<TSetType> builder, ReadOnlySpan<char> input, ref int i, int startThreshold, ref CurrentState currentState, ref int lastStart)
where TStateHandler : struct, IStateHandler
{
// To avoid frequent reads/writes to ref values, make and operate on local copies, which we then copy back once before returning.
int pos = i;
CurrentState state = currentState;
// Loop backwards through each character in the input, transitioning from state to state for each.
while (TryTakeTransition<TStateHandler>(builder, input, pos, ref state))
{
// We successfully transitioned. If the new state is a dead end, we're done, as we must have already seen
// and recorded a larger lastStart value that was the earliest valid starting position.
if (TStateHandler.IsDeadend(ref state))
{
Debug.Assert(lastStart != -1);
currentState = state;
i = pos;
return true;
}
// If the new state accepts the empty string, we found a valid starting position. Record it and keep going,
// since we're looking for the earliest one to occur within bounds.
if (TStateHandler.IsNullable(ref state, GetCharKind(input, pos - 1)))
{
lastStart = pos;
}
// Since we successfully transitioned, update our current index to match the fact that we consumed the previous character in the input.
pos--;
// If doing so now puts us below the start threshold, bail; we should have already found a valid starting location.
if (pos < startThreshold)
{
Debug.Assert(lastStart != -1);
currentState = state;
i = pos;
return true;
}
}
// Unable to transition further.
currentState = state;
i = pos;
return false;
}
/// <summary>Performs the initial Phase 1 match to find the first final state encountered.</summary>
/// <param name="input">The input text.</param>
/// <param name="i">The starting position in <paramref name="input"/>.</param>
/// <param name="timeoutOccursAt">The time at which timeout occurs, if timeouts are being checked.</param>
/// <param name="initialStateIndex">The last position the initial state of <see cref="_dotStarredPattern"/> was visited.</param>
/// <param name="matchLength">Length of the match if there's a match; otherwise, -1.</param>
/// <param name="perThreadData">Per thread data reused between calls.</param>
/// <returns>The index into input that matches the final state, or NoMatchExists if no match exists. It returns -1 when i=0 and the initial state is nullable.</returns>
private int FindFinalStatePosition(ReadOnlySpan<char> input, int i, int timeoutOccursAt, out int initialStateIndex, out int matchLength, PerThreadData perThreadData)
{
matchLength = -1;
initialStateIndex = i;
// Start with the start state of the dot-star pattern, which in general depends on the previous character kind in the input in order to handle anchors.
// If the starting state is a dead end, then no match exists.
var currentState = new CurrentState(_dotstarredInitialStates[GetCharKind(input, i - 1)]);
if (currentState.DfaState!.IsNothing)
{
// This can happen, for example, when the original regex starts with a beginning anchor but the previous char kind is not Beginning.
return NoMatchExists;
}
// If the starting state accepts the empty string in this context (factoring in anchors), we're done.
if (currentState.DfaState.IsNullable(GetCharKind(input, i)))
{
// The initial state is nullable in this context so at least an empty match exists.
// The last position of the match is i - 1 because the match is empty.
// This value is -1 if i == 0.
return i - 1;
}
// Otherwise, start searching from the current position until the end of the input.
if ((uint)i < (uint)input.Length)
{
SymbolicRegexBuilder<TSetType> builder = currentState.DfaState.Node._builder;
while (true)
{
// If we're at an initial state, try to search ahead for the next possible match location
// using any find optimizations that may have previously been computed.
if (currentState.DfaState is { IsInitialState: true })
{
// i is the most recent position in the input when the dot-star pattern is in the initial state
initialStateIndex = i;
if (_findOpts is RegexFindOptimizations findOpts)
{
// Find the first position i that matches with some likely character.
if (!findOpts.TryFindNextStartingPosition(input, ref i, 0))
{
// no match was found
return NoMatchExists;
}
initialStateIndex = i;
// Update the starting state based on where TryFindNextStartingPosition moved us to.
// As with the initial starting state, if it's a dead end, no match exists.
currentState = new CurrentState(_dotstarredInitialStates[GetCharKind(input, i - 1)]);
if (currentState.DfaState!.IsNothing)
{
return NoMatchExists;
}
}
}
// Now run the DFA or NFA traversal from the current point using the current state. If timeouts are being checked,
// we need to pop out of the inner loop every now and then to do the timeout check in this outer loop.
const int CharsPerTimeoutCheck = 10_000;
ReadOnlySpan<char> inputForInnerLoop = _checkTimeout && input.Length - i > CharsPerTimeoutCheck ?
input.Slice(0, i + CharsPerTimeoutCheck) :
input;
int finalStatePosition;
int findResult = currentState.NfaState is not null ?
FindFinalStatePositionDeltas<NfaStateHandler>(builder, inputForInnerLoop, ref i, ref currentState, ref matchLength, out finalStatePosition) :
FindFinalStatePositionDeltas<DfaStateHandler>(builder, inputForInnerLoop, ref i, ref currentState, ref matchLength, out finalStatePosition);
// If we reached a final or deadend state, we're done.
if (findResult > 0)
{
return finalStatePosition;
}
// We're not at an end state, so we either ran out of input (in which case no match exists), hit an initial state (in which case
// we want to loop around to apply our initial state processing logic and optimizations), or failed to transition (which should
// only happen if we were in DFA mode and need to switch over to NFA mode). If we exited because we hit an initial state,
// find result will be 0, otherwise negative.
if (findResult < 0)
{
if (i >= input.Length)
{
// We ran out of input. No match.
break;
}
if (i < inputForInnerLoop.Length)
{
// We failed to transition. Upgrade to DFA mode.
Debug.Assert(currentState.DfaState is not null);
NfaMatchingState nfaState = perThreadData.NfaState;
nfaState.InitializeFrom(currentState.DfaState);
currentState = new CurrentState(nfaState);
}
}
// Check for a timeout before continuing.
if (_checkTimeout)
{
DoCheckTimeout(timeoutOccursAt);
}
}
}
// No match was found.
return NoMatchExists;
}
/// <summary>
/// Workhorse inner loop for <see cref="FindFinalStatePosition"/>. Consumes the <paramref name="input"/> character by character,
/// starting at <paramref name="i"/>, for each character transitioning from one state in the DFA or NFA graph to the next state,
/// lazily building out the graph as needed.
/// </summary>
/// <remarks>
/// The <typeparamref name="TStateHandler"/> supplies the actual transitioning logic, controlling whether processing is
/// performed in DFA mode or in NFA mode. However, it expects <paramref name="currentState"/> to be configured to match,
/// so for example if <typeparamref name="TStateHandler"/> is a <see cref="DfaStateHandler"/>, it expects the <paramref name="currentState"/>'s
/// <see cref="CurrentState.DfaState"/> to be non-null and its <see cref="CurrentState.NfaState"/> to be null; vice versa for
/// <see cref="NfaStateHandler"/>.
/// </remarks>
/// <returns>
/// A positive value if iteration completed because it reached a nullable or deadend state.
/// 0 if iteration completed because we reached an initial state.
/// A negative value if iteration completed because we ran out of input or we failed to transition.
/// </returns>
private int FindFinalStatePositionDeltas<TStateHandler>(SymbolicRegexBuilder<TSetType> builder, ReadOnlySpan<char> input, ref int i, ref CurrentState currentState, ref int matchLength, out int finalStatePosition)
where TStateHandler : struct, IStateHandler
{
// To avoid frequent reads/writes to ref values, make and operate on local copies, which we then copy back once before returning.
int pos = i;
CurrentState state = currentState;
// Loop through each character in the input, transitioning from state to state for each.
while ((uint)pos < (uint)input.Length && TryTakeTransition<TStateHandler>(builder, input, pos, ref state))
{
// We successfully transitioned for the character at index i. If the new state is nullable for
// the next character, meaning it accepts the empty string, we found a final state and are done!
if (TStateHandler.IsNullable(ref state, GetCharKind(input, pos + 1)))
{
// Check whether there's a fixed-length marker for the current state. If there is, we can
// use that length to optimize subsequent matching phases.
matchLength = TStateHandler.FixedLength(ref state);
currentState = state;
i = pos;
finalStatePosition = pos;
return 1;
}
// If the new state is a dead end, such that we didn't match and we can't transition anywhere
// else, then no match exists.
if (TStateHandler.IsDeadend(ref state))
{
currentState = state;
i = pos;
finalStatePosition = NoMatchExists;
return 1;
}
// We successfully transitioned, so update our current input index to match.
pos++;
// Now that currentState and our position are coherent, check if currentState represents an initial state.
// If it does, we exit out in order to allow our find optimizations to kick in to hopefully more quickly
// find the next possible starting location.
if (TStateHandler.IsInitialState(ref state))
{
currentState = state;
i = pos;
finalStatePosition = 0;
return 0;
}
}
currentState = state;
i = pos;
finalStatePosition = 0;
return -1;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private uint GetCharKind(ReadOnlySpan<char> input, int i)
{
return !_pattern._info.ContainsSomeAnchor ?
CharKind.General : // The previous character kind is irrelevant when anchors are not used.
GetCharKindWithAnchor(input, i);
uint GetCharKindWithAnchor(ReadOnlySpan<char> input, int i)
{
Debug.Assert(_asciiCharKinds is not null);
if ((uint)i >= (uint)input.Length)
{
return CharKind.BeginningEnd;
}
char nextChar = input[i];
if (nextChar == '\n')
{
return
_builder._newLinePredicate.Equals(_builder._solver.False) ? 0 : // ignore \n
i == 0 || i == input.Length - 1 ? CharKind.NewLineS : // very first or very last \n. Detection of very first \n is needed for rev(\Z).
CharKind.Newline;
}
uint[] asciiCharKinds = _asciiCharKinds;
return
nextChar < (uint)asciiCharKinds.Length ? asciiCharKinds[nextChar] :
_builder._solver.And(GetMinterm(nextChar), _builder._wordLetterPredicateForAnchors).Equals(_builder._solver.False) ? 0 : //apply the wordletter predicate to compute the kind of the next character
CharKind.WordLetter;
}
}
/// <summary>Stores additional data for tracking capture start and end positions.</summary>
/// <remarks>The NFA simulation based third phase has one of these for each current state in the current set of live states.</remarks>
internal struct Registers
{
public Registers(int[] captureStarts, int[] captureEnds)
{
CaptureStarts = captureStarts;
CaptureEnds = captureEnds;
}
public int[] CaptureStarts { get; set; }
public int[] CaptureEnds { get; set; }
/// <summary>
/// Applies a list of effects in order to these registers at the provided input position. The order of effects
/// should not matter though, as multiple effects to the same capture start or end do not arise.
/// </summary>
/// <param name="effects">list of effects to be applied</param>
/// <param name="pos">the current input position to record</param>
public void ApplyEffects(DerivativeEffect[] effects, int pos)
{
foreach (DerivativeEffect effect in effects)
{
ApplyEffect(effect, pos);
}
}
/// <summary>
/// Apply a single effect to these registers at the provided input position.
/// </summary>
/// <param name="effect">the effecto to be applied</param>
/// <param name="pos">the current input position to record</param>
public void ApplyEffect(DerivativeEffect effect, int pos)
{
switch (effect.Kind)
{
case DerivativeEffectKind.CaptureStart:
CaptureStarts[effect.CaptureNumber] = pos;
break;
case DerivativeEffectKind.CaptureEnd:
CaptureEnds[effect.CaptureNumber] = pos;
break;
}
}
/// <summary>
/// Make a copy of this set of registers.
/// </summary>
/// <returns>Registers pointing to copies of this set of registers</returns>
public Registers Clone() => new Registers((int[])CaptureStarts.Clone(), (int[])CaptureEnds.Clone());
/// <summary>
/// Copy register values from another set of registers, possibly allocating new arrays if they were not yet allocated.
/// </summary>
/// <param name="other">the registers to copy from</param>
public void Assign(Registers other)
{
if (CaptureStarts is not null && CaptureEnds is not null)
{
Debug.Assert(CaptureStarts.Length == other.CaptureStarts.Length);
Debug.Assert(CaptureEnds.Length == other.CaptureEnds.Length);
Array.Copy(other.CaptureStarts, CaptureStarts, CaptureStarts.Length);
Array.Copy(other.CaptureEnds, CaptureEnds, CaptureEnds.Length);
}
else
{
CaptureStarts = (int[])other.CaptureStarts.Clone();
CaptureEnds = (int[])other.CaptureEnds.Clone();
}
}
}
/// <summary>
/// Per thread data to be held by the regex runner and passed into every call to FindMatch. This is used to
/// avoid repeated memory allocation.
/// </summary>
internal sealed class PerThreadData
{
public readonly NfaMatchingState NfaState;
/// <summary>Maps used for the capturing third phase.</summary>
public readonly SparseIntMap<Registers>? Current, Next;
/// <summary>Registers used for the capturing third phase.</summary>
public readonly Registers InitialRegisters;
public PerThreadData(SymbolicRegexBuilder<TSetType> builder, int capsize)
{
NfaState = new NfaMatchingState(builder);
// Only create data used for capturing mode if there are subcaptures
if (capsize > 1)
{
Current = new();
Next = new();
InitialRegisters = new Registers(new int[capsize], new int[capsize]);
}
}
}
/// <summary>Stores the state that represents a current state in NFA mode.</summary>
/// <remarks>The entire state is composed of a list of individual states.</remarks>
internal sealed class NfaMatchingState
{
/// <summary>The associated builder used to lazily add new DFA or NFA nodes to the graph.</summary>
public readonly SymbolicRegexBuilder<TSetType> Builder;
/// <summary>Ordered set used to store the current NFA states.</summary>
/// <remarks>The value is unused. The type is used purely for its keys.</remarks>
public SparseIntMap<int> NfaStateSet = new();
/// <summary>Scratch set to swap with <see cref="NfaStateSet"/> on each transition.</summary>
/// <remarks>
/// On each transition, <see cref="NfaStateSetScratch"/> is cleared and filled with the next
/// states computed from the current states in <see cref="NfaStateSet"/>, and then the sets
/// are swapped so the scratch becomes the current and the current becomes the scratch.
/// </remarks>
public SparseIntMap<int> NfaStateSetScratch = new();
/// <summary>Create the instance.</summary>
/// <remarks>New instances should only be created once per runner.</remarks>
public NfaMatchingState(SymbolicRegexBuilder<TSetType> builder) => Builder = builder;
/// <summary>Resets this NFA state to represent the supplied DFA state.</summary>
/// <param name="dfaMatchingState">The DFA state to use to initialize the NFA state.</param>
public void InitializeFrom(DfaMatchingState<TSetType> dfaMatchingState)
{
NfaStateSet.Clear();
// If the DFA state is a union of multiple DFA states, loop through all of them
// adding an NFA state for each.
if (dfaMatchingState.Node.Kind is SymbolicRegexNodeKind.Or)
{
Debug.Assert(dfaMatchingState.Node._alts is not null);
foreach (SymbolicRegexNode<TSetType> node in dfaMatchingState.Node._alts)
{
// Create (possibly new) NFA states for all the members.
// Add their IDs to the current set of NFA states and into the list.
int nfaState = Builder.CreateNfaState(node, dfaMatchingState.PrevCharKind);
NfaStateSet.Add(nfaState, out _);
}
}
else
{
// Otherwise, just add an NFA state for the singular DFA state.
SymbolicRegexNode<TSetType> node = dfaMatchingState.Node;
int nfaState = Builder.CreateNfaState(node, dfaMatchingState.PrevCharKind);
NfaStateSet.Add(nfaState, out _);
}
}
}
/// <summary>Represents a current state in a DFA or NFA graph walk while processing a regular expression.</summary>
/// <remarks>This is a discriminated union between a DFA state and an NFA state. One and only one will be non-null.</remarks>
private struct CurrentState
{
/// <summary>Initializes the state as a DFA state.</summary>
public CurrentState(DfaMatchingState<TSetType> dfaState)
{
DfaState = dfaState;
NfaState = null;
}
/// <summary>Initializes the state as an NFA state.</summary>
public CurrentState(NfaMatchingState nfaState)
{
DfaState = null;
NfaState = nfaState;
}
/// <summary>The DFA state.</summary>
public DfaMatchingState<TSetType>? DfaState;
/// <summary>The NFA state.</summary>
public NfaMatchingState? NfaState;
}
/// <summary>Represents a set of routines for operating over a <see cref="CurrentState"/>.</summary>
private interface IStateHandler
{
#pragma warning disable CA2252 // This API requires opting into preview features
public static abstract bool StartsWithLineAnchor(ref CurrentState state);
public static abstract bool IsNullable(ref CurrentState state, uint nextCharKind);
public static abstract bool IsDeadend(ref CurrentState state);
public static abstract int FixedLength(ref CurrentState state);
public static abstract bool IsInitialState(ref CurrentState state);
public static abstract bool TakeTransition(SymbolicRegexBuilder<TSetType> builder, ref CurrentState state, int mintermId);
#pragma warning restore CA2252 // This API requires opting into preview features
}
/// <summary>An <see cref="IStateHandler"/> for operating over <see cref="CurrentState"/> instances configured as DFA states.</summary>
private readonly struct DfaStateHandler : IStateHandler
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool StartsWithLineAnchor(ref CurrentState state) => state.DfaState!.StartsWithLineAnchor;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool IsNullable(ref CurrentState state, uint nextCharKind) => state.DfaState!.IsNullable(nextCharKind);
/// <summary>Gets whether this is a dead-end state, meaning there are no transitions possible out of the state.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool IsDeadend(ref CurrentState state) => state.DfaState!.IsDeadend;
/// <summary>Gets the length of any fixed-length marker that exists for this state, or -1 if there is none.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int FixedLength(ref CurrentState state) => state.DfaState!.FixedLength;
/// <summary>Gets whether this is an initial state.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool IsInitialState(ref CurrentState state) => state.DfaState!.IsInitialState;
/// <summary>Take the transition to the next DFA state.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool TakeTransition(SymbolicRegexBuilder<TSetType> builder, ref CurrentState state, int mintermId)
{
Debug.Assert(state.DfaState is not null, $"Expected non-null {nameof(state.DfaState)}.");
Debug.Assert(state.NfaState is null, $"Expected null {nameof(state.NfaState)}.");
Debug.Assert(builder._delta is not null);
// Get the current state.
DfaMatchingState<TSetType> dfaMatchingState = state.DfaState!;
// Use the mintermId for the character being read to look up which state to transition to.
// If that state has already been materialized, move to it, and we're done. If that state
// hasn't been materialized, try to create it; if we can, move to it, and we're done.
int dfaOffset = (dfaMatchingState.Id << builder._mintermsLog) | mintermId;
DfaMatchingState<TSetType>? nextState = builder._delta[dfaOffset];
if (nextState is not null || builder.TryCreateNewTransition(dfaMatchingState, mintermId, dfaOffset, checkThreshold: true, out nextState))
{
// There was an existing state for this transition or we were able to create one. Move to it and
// return that we're still operating as a DFA and can keep going.
state.DfaState = nextState;
return true;
}
return false;
}
}
/// <summary>An <see cref="IStateHandler"/> for operating over <see cref="CurrentState"/> instances configured as NFA states.</summary>
private readonly struct NfaStateHandler : IStateHandler
{
/// <summary>Check if any underlying core state starts with a line anchor.</summary>
public static bool StartsWithLineAnchor(ref CurrentState state)
{
SymbolicRegexBuilder<TSetType> builder = state.NfaState!.Builder;
foreach (ref KeyValuePair<int, int> nfaState in CollectionsMarshal.AsSpan(state.NfaState!.NfaStateSet.Values))
{
if (builder.GetCoreState(nfaState.Key).StartsWithLineAnchor)
{
return true;
}
}
return false;
}
/// <summary>Check if any underlying core state is nullable.</summary>
public static bool IsNullable(ref CurrentState state, uint nextCharKind)
{
SymbolicRegexBuilder<TSetType> builder = state.NfaState!.Builder;
foreach (ref KeyValuePair<int, int> nfaState in CollectionsMarshal.AsSpan(state.NfaState!.NfaStateSet.Values))
{
if (builder.GetCoreState(nfaState.Key).IsNullable(nextCharKind))
{
return true;
}
}
return false;
}
/// <summary>Gets whether this is a dead-end state, meaning there are no transitions possible out of the state.</summary>
/// <remarks>In NFA mode, an empty set of states means that it is a dead end.</remarks>
public static bool IsDeadend(ref CurrentState state) => state.NfaState!.NfaStateSet.Count == 0;
/// <summary>Gets the length of any fixed-length marker that exists for this state, or -1 if there is none.</summary>
/// <summary>In NFA mode, there are no fixed-length markers.</summary>
public static int FixedLength(ref CurrentState state) => -1;
/// <summary>Gets whether this is an initial state.</summary>
/// <summary>In NFA mode, no set of states qualifies as an initial state.</summary>
public static bool IsInitialState(ref CurrentState state) => false;
/// <summary>Take the transition to the next NFA state.</summary>
public static bool TakeTransition(SymbolicRegexBuilder<TSetType> builder, ref CurrentState state, int mintermId)
{
Debug.Assert(state.DfaState is null, $"Expected null {nameof(state.DfaState)}.");
Debug.Assert(state.NfaState is not null, $"Expected non-null {nameof(state.NfaState)}.");
NfaMatchingState nfaState = state.NfaState!;
// Grab the sets, swapping the current active states set with the scratch set.
SparseIntMap<int> nextStates = nfaState.NfaStateSetScratch;
SparseIntMap<int> sourceStates = nfaState.NfaStateSet;
nfaState.NfaStateSet = nextStates;
nfaState.NfaStateSetScratch = sourceStates;
// Compute the set of all unique next states from the current source states and the mintermId.
nextStates.Clear();
if (sourceStates.Count == 1)
{
// We have a single source state. We know its next states are already deduped,
// so we can just add them directly to the destination states list.
foreach (int nextState in GetNextStates(sourceStates.Values[0].Key, mintermId, builder))
{
nextStates.Add(nextState, out _);
}
}
else
{
// We have multiple source states, so we need to potentially dedup across each of
// their next states. For each source state, get its next states, adding each into
// our set (which exists purely for deduping purposes), and if we successfully added
// to the set, then add the known-unique state to the destination list.
foreach (ref KeyValuePair<int, int> sourceState in CollectionsMarshal.AsSpan(sourceStates.Values))
{
foreach (int nextState in GetNextStates(sourceState.Key, mintermId, builder))
{
nextStates.Add(nextState, out _);
}
}
}
return true;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static int[] GetNextStates(int sourceState, int mintermId, SymbolicRegexBuilder<TSetType> builder)
{
// Calculate the offset into the NFA transition table.
int nfaOffset = (sourceState << builder._mintermsLog) | mintermId;
// Get the next NFA state.
return builder._nfaDelta[nfaOffset] ?? builder.CreateNewNfaTransition(sourceState, mintermId, nfaOffset);
}
}
}
#if DEBUG
public override void SaveDGML(TextWriter writer, bool nfa, bool addDotStar, bool reverse, int maxStates, int maxLabelLength) =>
DgmlWriter<TSetType>.Write(writer, this, nfa, addDotStar, reverse, maxStates, maxLabelLength);
public override IEnumerable<string> GenerateRandomMembers(int k, int randomseed, bool negative) =>
new SymbolicRegexSampler<TSetType>(_pattern, randomseed, negative).GenerateRandomMembers(k);
#endif
}
}
| 1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexNode.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Threading;
namespace System.Text.RegularExpressions.Symbolic
{
/// <summary>Represents an AST node of a symbolic regex.</summary>
internal sealed class SymbolicRegexNode<S> where S : notnull
{
internal const string EmptyCharClass = "[]";
/// <summary>Some byte other than 0 to represent true</summary>
internal const byte TrueByte = 1;
/// <summary>Some byte other than 0 to represent false</summary>
internal const byte FalseByte = 2;
/// <summary>The undefined value is the default value 0</summary>
internal const byte UndefinedByte = 0;
internal readonly SymbolicRegexBuilder<S> _builder;
internal readonly SymbolicRegexNodeKind _kind;
internal readonly int _lower;
internal readonly int _upper;
internal readonly S? _set;
internal readonly SymbolicRegexNode<S>? _left;
internal readonly SymbolicRegexNode<S>? _right;
internal readonly SymbolicRegexSet<S>? _alts;
/// <summary>
/// Caches nullability of this node for any given context (0 <= context < ContextLimit)
/// when _info.StartsWithSomeAnchor and _info.CanBeNullable are true. Otherwise the cache is null.
/// </summary>
private byte[]? _nullabilityCache;
private S _startSet;
/// <summary>AST node of a symbolic regex</summary>
/// <param name="builder">the builder</param>
/// <param name="kind">what kind of node</param>
/// <param name="left">left child</param>
/// <param name="right">right child</param>
/// <param name="lower">lower bound of a loop</param>
/// <param name="upper">upper boubd of a loop</param>
/// <param name="set">singelton set</param>
/// <param name="alts">alternatives set of a disjunction or conjunction</param>
/// <param name="info">misc flags including laziness</param>
private SymbolicRegexNode(SymbolicRegexBuilder<S> builder, SymbolicRegexNodeKind kind, SymbolicRegexNode<S>? left, SymbolicRegexNode<S>? right, int lower, int upper, S? set, SymbolicRegexSet<S>? alts, SymbolicRegexInfo info)
{
_builder = builder;
_kind = kind;
_left = left;
_right = right;
_lower = lower;
_upper = upper;
_set = set;
_alts = alts;
_info = info;
_hashcode = ComputeHashCode();
_startSet = ComputeStartSet();
_nullabilityCache = info.StartsWithSomeAnchor && info.CanBeNullable ? new byte[CharKind.ContextLimit] : null;
}
private bool _isInternalizedUnion;
/// <summary> Create a new node or retrieve one from the builder _nodeCache</summary>
private static SymbolicRegexNode<S> Create(SymbolicRegexBuilder<S> builder, SymbolicRegexNodeKind kind, SymbolicRegexNode<S>? left, SymbolicRegexNode<S>? right, int lower, int upper, S? set, SymbolicRegexSet<S>? alts, SymbolicRegexInfo info)
{
SymbolicRegexNode<S>? node;
var key = (kind, left, right, lower, upper, set, alts, info);
if (!builder._nodeCache.TryGetValue(key, out node))
{
// Do not internalize top level Or-nodes or else NFA mode will become ineffective
if (kind == SymbolicRegexNodeKind.Or)
{
node = new(builder, kind, left, right, lower, upper, set, alts, info);
return node;
}
left = left == null || left._kind != SymbolicRegexNodeKind.Or || left._isInternalizedUnion ? left : Internalize(left);
right = right == null || right._kind != SymbolicRegexNodeKind.Or || right._isInternalizedUnion ? right : Internalize(right);
node = new(builder, kind, left, right, lower, upper, set, alts, info);
builder._nodeCache[key] = node;
}
Debug.Assert(node is not null);
return node;
}
/// <summary> Internalize an Or-node that is not yet internalized</summary>
private static SymbolicRegexNode<S> Internalize(SymbolicRegexNode<S> node)
{
Debug.Assert(node._kind == SymbolicRegexNodeKind.Or && !node._isInternalizedUnion);
(SymbolicRegexNodeKind, SymbolicRegexNode<S>?, SymbolicRegexNode<S>?, int, int, S?, SymbolicRegexSet<S>?, SymbolicRegexInfo) node_key =
(SymbolicRegexNodeKind.Or, null, null, -1, -1, default(S), node._alts, node._info);
SymbolicRegexNode<S>? node1;
if (node._builder._nodeCache.TryGetValue(node_key, out node1))
{
Debug.Assert(node1 is not null && node1._isInternalizedUnion);
return node1;
}
else
{
node._isInternalizedUnion = true;
node._builder._nodeCache[node_key] = node;
return node;
}
}
/// <summary>True if this node only involves lazy loops</summary>
internal bool IsLazy => _info.IsLazy;
/// <summary>True if this node accepts the empty string unconditionally.</summary>
internal bool IsNullable => _info.IsNullable;
/// <summary>True if this node can potentially accept the empty string depending on anchors and immediate context.</summary>
internal bool CanBeNullable
{
get
{
Debug.Assert(_info.CanBeNullable || !_info.IsNullable);
return _info.CanBeNullable;
}
}
internal SymbolicRegexInfo _info;
private readonly int _hashcode;
/// <summary>Converts a Concat or OrderdOr into an array, returns anything else in a singleton array.</summary>
/// <param name="list">a list to insert the elements into, or null to return results in a new list</param>
/// <param name="listKind">kind of node to consider as the list builder</param>
public List<SymbolicRegexNode<S>> ToList(List<SymbolicRegexNode<S>>? list = null, SymbolicRegexNodeKind listKind = SymbolicRegexNodeKind.Concat)
{
Debug.Assert(listKind == SymbolicRegexNodeKind.Concat || listKind == SymbolicRegexNodeKind.OrderedOr);
list ??= new List<SymbolicRegexNode<S>>();
AppendToList(this, list, listKind);
return list;
static void AppendToList(SymbolicRegexNode<S> concat, List<SymbolicRegexNode<S>> list, SymbolicRegexNodeKind listKind)
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
StackHelper.CallOnEmptyStack(AppendToList, concat, list, listKind);
return;
}
SymbolicRegexNode<S> node = concat;
while (node._kind == listKind)
{
Debug.Assert(node._left is not null && node._right is not null);
if (node._left._kind == listKind)
{
AppendToList(node._left, list, listKind);
}
else
{
list.Add(node._left);
}
node = node._right;
}
list.Add(node);
}
}
/// <summary>
/// Relative nullability that takes into account the immediate character context
/// in order to resolve nullability of anchors
/// </summary>
/// <param name="context">kind info for previous and next characters</param>
internal bool IsNullableFor(uint context)
{
// if _nullabilityCache is null then IsNullable==CanBeNullable
// Observe that if IsNullable==true then CanBeNullable==true.
// but when the node does not start with an anchor
// and IsNullable==false then CanBeNullable==false.
return _nullabilityCache is null ?
_info.IsNullable :
WithCache(context);
// Separated out to enable the common case (no nullability cache) to be inlined
// and to avoid zero-init costs for generally unused state.
bool WithCache(uint context)
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(IsNullableFor, context);
}
Debug.Assert(context < CharKind.ContextLimit);
// If nullablity has been computed for the given context then return it
byte b = Volatile.Read(ref _nullabilityCache[context]);
if (b != UndefinedByte)
{
return b == TrueByte;
}
// Otherwise compute the nullability recursively for the given context
bool is_nullable;
switch (_kind)
{
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
is_nullable = _lower == 0 || _left.IsNullableFor(context);
break;
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
is_nullable = _left.IsNullableFor(context) && _right.IsNullableFor(context);
break;
case SymbolicRegexNodeKind.Or:
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
is_nullable = _alts.IsNullableFor(context);
break;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
is_nullable = _left.IsNullableFor(context) || _right.IsNullableFor(context);
break;
case SymbolicRegexNodeKind.Not:
Debug.Assert(_left is not null);
is_nullable = !_left.IsNullableFor(context);
break;
case SymbolicRegexNodeKind.BeginningAnchor:
is_nullable = CharKind.Prev(context) == CharKind.BeginningEnd;
break;
case SymbolicRegexNodeKind.EndAnchor:
is_nullable = CharKind.Next(context) == CharKind.BeginningEnd;
break;
case SymbolicRegexNodeKind.BOLAnchor:
// Beg-Of-Line anchor is nullable when the previous character is Newline or Start
// note: at least one of the bits must be 1, but both could also be 1 in case of very first newline
is_nullable = (CharKind.Prev(context) & CharKind.NewLineS) != 0;
break;
case SymbolicRegexNodeKind.EOLAnchor:
// End-Of-Line anchor is nullable when the next character is Newline or Stop
// note: at least one of the bits must be 1, but both could also be 1 in case of \Z
is_nullable = (CharKind.Next(context) & CharKind.NewLineS) != 0;
break;
case SymbolicRegexNodeKind.BoundaryAnchor:
// test that prev char is word letter iff next is not not word letter
is_nullable = ((CharKind.Prev(context) & CharKind.WordLetter) ^ (CharKind.Next(context) & CharKind.WordLetter)) != 0;
break;
case SymbolicRegexNodeKind.NonBoundaryAnchor:
// test that prev char is word letter iff next is word letter
is_nullable = ((CharKind.Prev(context) & CharKind.WordLetter) ^ (CharKind.Next(context) & CharKind.WordLetter)) == 0;
break;
case SymbolicRegexNodeKind.EndAnchorZ:
// \Z anchor is nullable when the next character is either the last Newline or Stop
// note: CharKind.NewLineS == CharKind.Newline|CharKind.StartStop
is_nullable = (CharKind.Next(context) & CharKind.BeginningEnd) != 0;
break;
case SymbolicRegexNodeKind.CaptureStart:
case SymbolicRegexNodeKind.CaptureEnd:
is_nullable = true;
break;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
is_nullable = _left.IsNullableFor(context);
break;
default:
// SymbolicRegexNodeKind.EndAnchorZReverse:
// EndAnchorZRev (rev(\Z)) anchor is nullable when the prev character is either the first Newline or Start
// note: CharKind.NewLineS == CharKind.Newline|CharKind.StartStop
Debug.Assert(_kind == SymbolicRegexNodeKind.EndAnchorZReverse);
is_nullable = (CharKind.Prev(context) & CharKind.BeginningEnd) != 0;
break;
}
Volatile.Write(ref _nullabilityCache[context], is_nullable ? TrueByte : FalseByte);
return is_nullable;
}
}
/// <summary>Returns true if this is equivalent to .* (the node must be eager also)</summary>
public bool IsAnyStar
{
get
{
if (IsStar)
{
Debug.Assert(_left is not null);
if (_left._kind == SymbolicRegexNodeKind.Singleton)
{
Debug.Assert(_left._set is not null);
return !IsLazy && _builder._solver.True.Equals(_left._set);
}
}
return false;
}
}
/// <summary>Returns true if this is equivalent to .+ (the node must be eager also)</summary>
public bool IsAnyPlus
{
get
{
if (IsPlus)
{
Debug.Assert(_left is not null);
if (_left._kind == SymbolicRegexNodeKind.Singleton)
{
Debug.Assert(_left._set is not null);
return !IsLazy && _builder._solver.True.Equals(_left._set);
}
}
return false;
}
}
/// <summary>Returns true if this is equivalent to [\0-\xFFFF] </summary>
public bool IsAnyChar
{
get
{
if (_kind == SymbolicRegexNodeKind.Singleton)
{
Debug.Assert(_set is not null);
return _builder._solver.AreEquivalent(_builder._solver.True, _set);
}
return false;
}
}
/// <summary>Returns true if this is equivalent to [0-[0]]</summary>
public bool IsNothing
{
get
{
if (_kind == SymbolicRegexNodeKind.Singleton)
{
Debug.Assert(_set is not null);
return !_builder._solver.IsSatisfiable(_set);
}
return false;
}
}
/// <summary>Returns true iff this is a loop whose lower bound is 0 and upper bound is max</summary>
public bool IsStar => _lower == 0 && _upper == int.MaxValue;
/// <summary>Returns true if this is Epsilon</summary>
public bool IsEpsilon => _kind == SymbolicRegexNodeKind.Epsilon;
/// <summary>Gets the kind of the regex</summary>
internal SymbolicRegexNodeKind Kind => _kind;
/// <summary>
/// Returns true iff this is a loop whose lower bound is 1 and upper bound is max
/// </summary>
public bool IsPlus => _lower == 1 && _upper == int.MaxValue;
#region called only once, in the constructor of SymbolicRegexBuilder
internal static SymbolicRegexNode<S> CreateFalse(SymbolicRegexBuilder<S> builder) =>
Create(builder, SymbolicRegexNodeKind.Singleton, null, null, -1, -1, builder._solver.False, null, SymbolicRegexInfo.Create());
internal static SymbolicRegexNode<S> CreateTrue(SymbolicRegexBuilder<S> builder) =>
Create(builder, SymbolicRegexNodeKind.Singleton, null, null, -1, -1, builder._solver.True, null, SymbolicRegexInfo.Create(containsSomeCharacter: true));
internal static SymbolicRegexNode<S> CreateFixedLengthMarker(SymbolicRegexBuilder<S> builder, int length) =>
Create(builder, SymbolicRegexNodeKind.FixedLengthMarker, null, null, length, -1, default, null, SymbolicRegexInfo.Create(isAlwaysNullable: true));
internal static SymbolicRegexNode<S> CreateEpsilon(SymbolicRegexBuilder<S> builder) =>
Create(builder, SymbolicRegexNodeKind.Epsilon, null, null, -1, -1, default, null, SymbolicRegexInfo.Create(isAlwaysNullable: true));
internal static SymbolicRegexNode<S> CreateEagerEmptyLoop(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> body) =>
Create(builder, SymbolicRegexNodeKind.Loop, body, null, 0, 0, default, null, SymbolicRegexInfo.Create(isAlwaysNullable: true, isLazy: false));
internal static SymbolicRegexNode<S> CreateBeginEndAnchor(SymbolicRegexBuilder<S> builder, SymbolicRegexNodeKind kind)
{
Debug.Assert(kind is
SymbolicRegexNodeKind.BeginningAnchor or SymbolicRegexNodeKind.EndAnchor or
SymbolicRegexNodeKind.EndAnchorZ or SymbolicRegexNodeKind.EndAnchorZReverse or
SymbolicRegexNodeKind.EOLAnchor or SymbolicRegexNodeKind.BOLAnchor);
return Create(builder, kind, null, null, -1, -1, default, null, SymbolicRegexInfo.Create(startsWithLineAnchor: true, canBeNullable: true));
}
internal static SymbolicRegexNode<S> CreateBoundaryAnchor(SymbolicRegexBuilder<S> builder, SymbolicRegexNodeKind kind)
{
Debug.Assert(kind is SymbolicRegexNodeKind.BoundaryAnchor or SymbolicRegexNodeKind.NonBoundaryAnchor);
return Create(builder, kind, null, null, -1, -1, default, null, SymbolicRegexInfo.Create(startsWithBoundaryAnchor: true, canBeNullable: true));
}
#endregion
internal static SymbolicRegexNode<S> CreateSingleton(SymbolicRegexBuilder<S> builder, S set) =>
Create(builder, SymbolicRegexNodeKind.Singleton, null, null, -1, -1, set, null, SymbolicRegexInfo.Create(containsSomeCharacter: !set.Equals(builder._solver.False)));
internal static SymbolicRegexNode<S> CreateLoop(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> body, int lower, int upper, bool isLazy)
{
Debug.Assert(lower >= 0 && lower <= upper);
return Create(builder, SymbolicRegexNodeKind.Loop, body, null, lower, upper, default, null, SymbolicRegexInfo.Loop(body._info, lower, isLazy));
}
internal static SymbolicRegexNode<S> Or(SymbolicRegexBuilder<S> builder, params SymbolicRegexNode<S>[] disjuncts) =>
CreateCollection(builder, SymbolicRegexNodeKind.Or, SymbolicRegexSet<S>.CreateMulti(builder, disjuncts, SymbolicRegexNodeKind.Or), SymbolicRegexInfo.Or(GetInfos(disjuncts)));
internal static SymbolicRegexNode<S> Or(SymbolicRegexBuilder<S> builder, SymbolicRegexSet<S> disjuncts)
{
Debug.Assert(disjuncts._kind == SymbolicRegexNodeKind.Or || disjuncts.IsEverything);
return CreateCollection(builder, SymbolicRegexNodeKind.Or, disjuncts, SymbolicRegexInfo.Or(GetInfos(disjuncts)));
}
internal static SymbolicRegexNode<S> And(SymbolicRegexBuilder<S> builder, params SymbolicRegexNode<S>[] conjuncts) =>
CreateCollection(builder, SymbolicRegexNodeKind.And, SymbolicRegexSet<S>.CreateMulti(builder, conjuncts, SymbolicRegexNodeKind.And), SymbolicRegexInfo.And(GetInfos(conjuncts)));
internal static SymbolicRegexNode<S> And(SymbolicRegexBuilder<S> builder, SymbolicRegexSet<S> conjuncts)
{
Debug.Assert(conjuncts.IsNothing || conjuncts._kind == SymbolicRegexNodeKind.And);
return CreateCollection(builder, SymbolicRegexNodeKind.And, conjuncts, SymbolicRegexInfo.And(GetInfos(conjuncts)));
}
internal static SymbolicRegexNode<S> CreateCaptureStart(SymbolicRegexBuilder<S> builder, int captureNum) =>
Create(builder, SymbolicRegexNodeKind.CaptureStart, null, null, captureNum, -1, default, null, SymbolicRegexInfo.Create(isAlwaysNullable: true));
internal static SymbolicRegexNode<S> CreateCaptureEnd(SymbolicRegexBuilder<S> builder, int captureNum) =>
Create(builder, SymbolicRegexNodeKind.CaptureEnd, null, null, captureNum, -1, default, null, SymbolicRegexInfo.Create(isAlwaysNullable: true));
internal static SymbolicRegexNode<S> CreateDisableBacktrackingSimulation(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> child) =>
Create(builder, SymbolicRegexNodeKind.DisableBacktrackingSimulation, child, null, -1, -1, default, null, child._info);
private static SymbolicRegexNode<S> CreateCollection(SymbolicRegexBuilder<S> builder, SymbolicRegexNodeKind kind, SymbolicRegexSet<S> alts, SymbolicRegexInfo info) =>
alts.IsNothing ? builder._nothing :
alts.IsEverything ? builder._anyStar :
alts.IsSingleton ? alts.GetSingletonElement() :
Create(builder, kind, null, null, -1, -1, default, alts, info);
private static SymbolicRegexInfo[] GetInfos(SymbolicRegexNode<S>[] nodes)
{
var infos = new SymbolicRegexInfo[nodes.Length];
for (int i = 0; i < nodes.Length; i++)
{
infos[i] = nodes[i]._info;
}
return infos;
}
private static SymbolicRegexInfo[] GetInfos(SymbolicRegexSet<S> nodes)
{
var infos = new SymbolicRegexInfo[nodes.Count];
int i = 0;
foreach (SymbolicRegexNode<S> node in nodes)
{
Debug.Assert(i < nodes.Count);
infos[i++] = node._info;
}
Debug.Assert(i == nodes.Count);
return infos;
}
/// <summary>Make a concatenation of the supplied regex nodes.</summary>
internal static SymbolicRegexNode<S> CreateConcat(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> left, SymbolicRegexNode<S> right)
{
// Concatenating anything with a nothing means the entire concatenation can't match
if (left == builder._nothing || right == builder._nothing)
return builder._nothing;
// If the left or right is empty, just return the other.
if (left.IsEpsilon)
return right;
if (right.IsEpsilon)
return left;
// If the left isn't a concatenation, then proceed to concatenation the left with the right.
if (left._kind != SymbolicRegexNodeKind.Concat)
{
return Create(builder, SymbolicRegexNodeKind.Concat, left, right, -1, -1, default, null, SymbolicRegexInfo.Concat(left._info, right._info));
}
// The left is a concatenation. We want to flatten it out and maintain a right-associative form.
SymbolicRegexNode<S> concat = right;
List<SymbolicRegexNode<S>> leftNodes = left.ToList();
for (int i = leftNodes.Count - 1; i >= 0; i--)
{
concat = Create(builder, SymbolicRegexNodeKind.Concat, leftNodes[i], concat, -1, -1, default, null, SymbolicRegexInfo.Concat(leftNodes[i]._info, concat._info));
}
return concat;
}
/// <summary>
/// Make an ordered or of given regexes, eliminate nothing regexes and treat .* as consuming element.
/// Keep the or flat, assuming both right and left are flat.
/// Apply a counber subsumption/combining optimization, such that e.g. a{2,5}|a{3,10} will be combined to a{2,10}.
/// </summary>
internal static SymbolicRegexNode<S> OrderedOr(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> left, SymbolicRegexNode<S> right, bool deduplicated = false)
{
if (left.IsAnyStar || right == builder._nothing || left == right)
return left;
if (left == builder._nothing)
return right;
// If left is not an Or, try to avoid allocation by checking if deduplication is necessary
if (!deduplicated && left._kind != SymbolicRegexNodeKind.OrderedOr)
{
SymbolicRegexNode<S> current = right;
// Initially assume there are no duplicates
deduplicated = true;
while (current._kind == SymbolicRegexNodeKind.OrderedOr)
{
Debug.Assert(current._left is not null && current._right is not null);
// All Ors are supposed to be in a right associative normal form
Debug.Assert(current._left._kind != SymbolicRegexNodeKind.OrderedOr);
if (current._left == left)
{
// Duplicate found, mark that and exit early
deduplicated = false;
break;
}
current = current._right;
}
// If the loop above got to the end, current is the last element. Check that too
if (deduplicated)
deduplicated = (current != left);
}
if (!deduplicated || left._kind == SymbolicRegexNodeKind.OrderedOr)
{
// If the left side was an or, then it has to be flattened, gather the elements from both sides
List<SymbolicRegexNode<S>> elems = left.ToList(listKind: SymbolicRegexNodeKind.OrderedOr);
int firstRightElem = elems.Count;
right.ToList(elems, listKind: SymbolicRegexNodeKind.OrderedOr);
// Eliminate any duplicate elements, keeping the leftmost element
HashSet<SymbolicRegexNode<S>> seenElems = new();
// Keep track of if any elements from the right side need to be eliminated
bool rightChanged = false;
for (int i = 0; i < elems.Count; i++)
{
if (!seenElems.Contains(elems[i]))
{
seenElems.Add(elems[i]);
}
else
{
// Nothing will be eliminated in the next step
elems[i] = builder._nothing;
rightChanged |= i >= firstRightElem;
}
}
// Build the flattened or, avoiding rebuilding the right side if possible
if (rightChanged)
{
SymbolicRegexNode<S> or = builder._nothing;
for (int i = elems.Count - 1; i >= 0; i--)
{
or = OrderedOr(builder, elems[i], or, deduplicated: true);
}
return or;
}
else
{
SymbolicRegexNode<S> or = right;
for (int i = firstRightElem - 1; i >= 0; i--)
{
or = OrderedOr(builder, elems[i], or, deduplicated: true);
}
return or;
}
}
Debug.Assert(left._kind != SymbolicRegexNodeKind.OrderedOr);
Debug.Assert(deduplicated);
// Apply the counter subsumption/combining optimization if possible
(SymbolicRegexNode<S> loop, SymbolicRegexNode<S> rest) = left.FirstCounterInfo();
if (loop != builder._nothing)
{
Debug.Assert(loop._kind == SymbolicRegexNodeKind.Loop && loop._left is not null);
(SymbolicRegexNode<S> otherLoop, SymbolicRegexNode<S> otherRest) = right.FirstCounterInfo();
if (otherLoop != builder._nothing && rest == otherRest)
{
// Found two adjacent counters with the same continuation, check that the loops are equivalent apart from bounds
// and that the bounds form a contiguous interval. Two integer intervals [x1,x2] and [y1,y2] overlap when
// x1 <= y2 and y1 <= x2. The union of intervals that just touch is still contiguous, e.g. [2,5] and [6,10] make
// [2,10], so the lower bounds are decremented by 1 in the check.
Debug.Assert(otherLoop._kind == SymbolicRegexNodeKind.Loop && otherLoop._left is not null);
if (loop._left == otherLoop._left && loop.IsLazy == otherLoop.IsLazy &&
loop._lower - 1 <= otherLoop._upper && otherLoop._lower - 1 <= loop._upper)
{
// Loops are equivalent apart from bounds, and the union of the bounds is a contiguous interval
// Build a new counter for the union of the ranges
SymbolicRegexNode<S> newCounter = CreateConcat(builder, CreateLoop(builder, loop._left,
Math.Min(loop._lower, otherLoop._lower), Math.Max(loop._upper, otherLoop._upper), loop.IsLazy), rest);
if (right._kind == SymbolicRegexNodeKind.OrderedOr)
{
// The right counter came from an or, so include the rest of that or
Debug.Assert(right._right is not null);
return OrderedOr(builder, newCounter, right._right, deduplicated: true);
}
else
{
return newCounter;
}
}
}
}
// Counter optimization did not apply, just build the or
return Create(builder, SymbolicRegexNodeKind.OrderedOr, left, right, -1, -1, default, null, SymbolicRegexInfo.Or(left._info, right._info));
}
/// <summary>
/// Extract a counter as a loop followed by its continuation. For example, a*b returns (a*,b).
/// Also look into the first element of an or, so a+|xyz returns (a+,()).
/// If no counter is found returns ([],[]).
/// </summary>
/// <returns>a tuple of the loop and its continuation</returns>
private (SymbolicRegexNode<S>, SymbolicRegexNode<S>) FirstCounterInfo()
{
if (_kind == SymbolicRegexNodeKind.Loop)
return (this, _builder.Epsilon);
if (_kind == SymbolicRegexNodeKind.Concat)
{
Debug.Assert(_left is not null && _right is not null);
if (_left.Kind == SymbolicRegexNodeKind.Loop)
return (_left, _right);
}
if (_kind == SymbolicRegexNodeKind.OrderedOr)
{
Debug.Assert(_left is not null);
return _left.FirstCounterInfo();
}
return (_builder._nothing, _builder._nothing);
}
internal static SymbolicRegexNode<S> Not(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> root)
{
// Instead of just creating a negated root node
// Convert ~root to Negation Normal Form (NNF) by using deMorgan's laws and push ~ to the leaves
// This may avoid rather large overhead (such case was discovered with unit test PasswordSearchDual)
// Do this transformation in-line without recursion, to avoid any chance of deep recursion
// OBSERVE: NNF[node] represents the Negation Normal Form of ~node
Dictionary<SymbolicRegexNode<S>, SymbolicRegexNode<S>> NNF = new();
Stack<(SymbolicRegexNode<S>, bool)> todo = new();
todo.Push((root, false));
while (todo.Count > 0)
{
(SymbolicRegexNode<S>, bool) top = todo.Pop();
bool secondTimePushed = top.Item2;
SymbolicRegexNode<S> node = top.Item1;
if (secondTimePushed)
{
Debug.Assert((node._kind == SymbolicRegexNodeKind.Or || node._kind == SymbolicRegexNodeKind.And) && node._alts is not null);
// Here all members of _alts have been processed
List<SymbolicRegexNode<S>> alts_nnf = new();
foreach (SymbolicRegexNode<S> elem in node._alts)
{
alts_nnf.Add(NNF[elem]);
}
// Using deMorgan's laws, flip the kind: Or becomes And, And becomes Or
SymbolicRegexNode<S> node_nnf = node._kind == SymbolicRegexNodeKind.Or ? And(builder, alts_nnf.ToArray()) : Or(builder, alts_nnf.ToArray());
NNF[node] = node_nnf;
}
else
{
switch (node._kind)
{
case SymbolicRegexNodeKind.Not:
Debug.Assert(node._left is not null);
// Here we assume that top._left is already in NNF, double negation is cancelled out
NNF[node] = node._left;
break;
case SymbolicRegexNodeKind.Or or SymbolicRegexNodeKind.And:
Debug.Assert(node._alts is not null);
// Push the node for the second time
todo.Push((node, true));
// Compute the negation normal form of all the members
// Their computation is actually the same independent from being inside an 'Or' or 'And' node
foreach (SymbolicRegexNode<S> elem in node._alts)
{
todo.Push((elem, false));
}
break;
case SymbolicRegexNodeKind.Epsilon:
// ~() = .+
NNF[node] = SymbolicRegexNode<S>.CreateLoop(builder, builder._anyChar, 1, int.MaxValue, isLazy: false);
break;
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(node._set is not null);
// ~[] = .*
if (node.IsNothing)
{
NNF[node] = builder._anyStar;
break;
}
goto default;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(node._left is not null);
// ~(.*) = [] and ~(.+) = ()
if (node.IsAnyStar)
{
NNF[node] = builder._nothing;
break;
}
else if (node.IsPlus && node._left.IsAnyChar)
{
NNF[node] = builder.Epsilon;
break;
}
goto default;
default:
// In all other cases construct the complement
NNF[node] = Create(builder, SymbolicRegexNodeKind.Not, node, null, -1, -1, default, null, SymbolicRegexInfo.Not(node._info));
break;
}
}
}
return NNF[root];
}
/// <summary>
/// Returns the fixed matching length of the regex or -1 if the regex does not have a fixed matching length.
/// </summary>
public int GetFixedLength()
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
// If we can't recur further, assume no fixed length.
return -1;
}
switch (_kind)
{
case SymbolicRegexNodeKind.FixedLengthMarker:
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.BOLAnchor:
case SymbolicRegexNodeKind.EOLAnchor:
case SymbolicRegexNodeKind.EndAnchor:
case SymbolicRegexNodeKind.BeginningAnchor:
case SymbolicRegexNodeKind.EndAnchorZ:
case SymbolicRegexNodeKind.EndAnchorZReverse:
case SymbolicRegexNodeKind.BoundaryAnchor:
case SymbolicRegexNodeKind.NonBoundaryAnchor:
case SymbolicRegexNodeKind.CaptureStart:
case SymbolicRegexNodeKind.CaptureEnd:
return 0;
case SymbolicRegexNodeKind.Singleton:
return 1;
case SymbolicRegexNodeKind.Loop:
{
Debug.Assert(_left is not null);
if (_lower == _upper)
{
long length = _left.GetFixedLength();
if (length >= 0)
{
length *= _lower;
if (length <= int.MaxValue)
{
return (int)length;
}
}
}
break;
}
case SymbolicRegexNodeKind.Concat:
{
Debug.Assert(_left is not null && _right is not null);
int leftLength = _left.GetFixedLength();
if (leftLength >= 0)
{
int rightLength = _right.GetFixedLength();
if (rightLength >= 0)
{
long length = (long)leftLength + rightLength;
if (length <= int.MaxValue)
{
return (int)length;
}
}
}
break;
}
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
return _alts.GetFixedLength();
case SymbolicRegexNodeKind.OrderedOr:
{
Debug.Assert(_left is not null && _right is not null);
int length = _left.GetFixedLength();
if (length >= 0)
{
if (_right.GetFixedLength() == length)
{
return length;
}
}
break;
}
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
return _left.GetFixedLength();
}
return -1;
}
#if DEBUG
private TransitionRegex<S>? _transitionRegex;
/// <summary>
/// Computes the symbolic derivative as a transition regex.
/// Transitions are in the tree left to right in the order the backtracking engine would explore them.
/// </summary>
internal TransitionRegex<S> CreateDerivative()
{
if (_transitionRegex is not null)
{
return _transitionRegex;
}
if (IsNothing || IsEpsilon)
{
_transitionRegex = TransitionRegex<S>.Leaf(_builder._nothing);
return _transitionRegex;
}
if (IsAnyStar || IsAnyPlus)
{
_transitionRegex = TransitionRegex<S>.Leaf(_builder._anyStar);
return _transitionRegex;
}
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(CreateDerivative);
}
switch (_kind)
{
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(_set is not null);
_transitionRegex = TransitionRegex<S>.Conditional(_set, TransitionRegex<S>.Leaf(_builder.Epsilon), TransitionRegex<S>.Leaf(_builder._nothing));
break;
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
TransitionRegex<S> mainTransition = _left.CreateDerivative().Concat(_right);
if (!_left.CanBeNullable)
{
// If _left is never nullable
_transitionRegex = mainTransition;
}
else if (_left.IsNullable)
{
// If _left is unconditionally nullable
_transitionRegex = TransitionRegex<S>.Union(mainTransition, _right.CreateDerivative());
}
else
{
// The left side contains anchors and can be nullable in some context
// Extract the nullability as the lookaround condition
SymbolicRegexNode<S> leftNullabilityTest = _left.ExtractNullabilityTest();
_transitionRegex = TransitionRegex<S>.Lookaround(leftNullabilityTest, TransitionRegex<S>.Union(mainTransition, _right.CreateDerivative()), mainTransition);
}
break;
case SymbolicRegexNodeKind.Loop:
// d(R*) = d(R+) = d(R)R*
Debug.Assert(_left is not null);
Debug.Assert(_upper > 0);
TransitionRegex<S> step = _left.CreateDerivative();
if (IsStar || IsPlus)
{
_transitionRegex = step.Concat(_builder.CreateLoop(_left, IsLazy));
}
else
{
int newupper = _upper == int.MaxValue ? int.MaxValue : _upper - 1;
int newlower = _lower == 0 ? 0 : _lower - 1;
SymbolicRegexNode<S> rest = _builder.CreateLoop(_left, IsLazy, newlower, newupper);
_transitionRegex = step.Concat(rest);
}
break;
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
_transitionRegex = TransitionRegex<S>.Leaf(_builder._nothing);
foreach (SymbolicRegexNode<S> elem in _alts)
{
_transitionRegex = TransitionRegex<S>.Union(_transitionRegex, elem.CreateDerivative());
}
break;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
_transitionRegex = TransitionRegex<S>.Union(_left.CreateDerivative(), _right.CreateDerivative());
break;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
// The derivative to TransitionRegex does not support backtracking simulation, so ignore this node
_transitionRegex = _left.CreateDerivative();
break;
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
_transitionRegex = TransitionRegex<S>.Leaf(_builder._anyStar);
foreach (SymbolicRegexNode<S> elem in _alts)
{
_transitionRegex = TransitionRegex<S>.Intersect(_transitionRegex, elem.CreateDerivative());
}
break;
case SymbolicRegexNodeKind.Not:
Debug.Assert(_left is not null);
_transitionRegex = _left.CreateDerivative().Complement();
break;
default:
_transitionRegex = TransitionRegex<S>.Leaf(_builder._nothing);
break;
}
return _transitionRegex;
}
#endif
/// <summary>
/// Takes the derivative of the symbolic regex for the given element, which must be either
/// a minterm (i.e. a class of characters that have identical behavior for all predicates in the pattern)
/// or a singleton set. This derivative simulates backtracking, i.e. it only considers paths that backtracking would
/// take before accepting the empty string for this pattern and returns the pattern ordered in the order backtracking
/// would explore paths. For example the derivative of a*ab for a is a*ab|b, while for a*?ab it is b|a*?ab.
/// </summary>
/// <param name="elem">given element wrt which the derivative is taken</param>
/// <param name="context">immediately surrounding character context that affects nullability of anchors</param>
/// <returns>the derivative</returns>
internal SymbolicRegexNode<S> CreateDerivative(S elem, uint context)
{
List<(SymbolicRegexNode<S> Node, DerivativeEffect[])> transitions = new();
if (_kind == SymbolicRegexNodeKind.DisableBacktrackingSimulation)
{
// Since this node disables backtracking simulation, unwrap the node and pass the corresponding flag as
// false to AddTransitions.
Debug.Assert(_left is not null);
_left.AddTransitions(elem, context, transitions, new List<SymbolicRegexNode<S>>(), null, simulateBacktracking: false);
}
else
{
AddTransitions(elem, context, transitions, new List<SymbolicRegexNode<S>>(), null, simulateBacktracking: true);
}
SymbolicRegexNode<S> derivative = _builder._nothing;
// Iterate backwards to avoid quadratic rebuilding of the Or nodes, which are always simplified to
// right associative form. Concretely:
// In (a|(b|c)) | d -> (a|(b|(c|d)) the first argument is not a subtree of the result.
// In a | (b|(c|d)) -> (a|(b|(c|d)) the second argument is a subtree of the result.
// The first case performs linear work for each element, leading to a quadratic blowup.
for (int i = transitions.Count - 1; i >= 0; --i)
{
SymbolicRegexNode<S> node = transitions[i].Node;
Debug.Assert(node._kind != SymbolicRegexNodeKind.DisableBacktrackingSimulation);
derivative = _builder.OrderedOr(node, derivative);
}
if (_kind == SymbolicRegexNodeKind.DisableBacktrackingSimulation)
// Make future derivatives disable backtracking simulation too
derivative = _builder.CreateDisableBacktrackingSimulation(derivative);
return derivative;
}
/// <summary>
/// Takes the derivative of the symbolic regex for the given element, which must be either
/// a minterm (i.e. a class of characters that have identical behavior for all predicates in the pattern)
/// or a singleton set. This derivative simulates backtracking, i.e. it only considers paths that backtracking would
/// take before accepting the empty string for this pattern and returns the pattern ordered in the order backtracking
/// would explore paths. For example the derivative of a*ab places a*ab before b, while for a*?ab the order is reversed.
/// </summary>
/// <remarks>
/// The differences of this to <see cref="CreateDerivative(S,uint)"/> are that (1) effects (e.g. capture starts and ends)
/// are considered and (2) the different elements that would form a top level union are instead returned as separate
/// nodes (paired with their associated effects). This function is meant to be used for NFA simulation, where top level
/// unions would be broken up into separate states anyway, so nodes are not combined even if they have the same effects.
/// </remarks>
/// <param name="elem">given element wrt which the derivative is taken</param>
/// <param name="context">immediately surrounding character context that affects nullability of anchors</param>
/// <returns>the derivative</returns>
internal List<(SymbolicRegexNode<S>, DerivativeEffect[])> CreateNfaDerivativeWithEffects(S elem, uint context)
{
List<(SymbolicRegexNode<S>, DerivativeEffect[])> transitions = new();
if (_kind == SymbolicRegexNodeKind.DisableBacktrackingSimulation)
{
// Since this node disables backtracking simulation, unwrap the node and pass the corresponding flag as
// false to AddTransitions.
Debug.Assert(_left is not null);
_left.AddTransitions(elem, context, transitions, new List<SymbolicRegexNode<S>>(), new Stack<DerivativeEffect>(), simulateBacktracking: false);
// Make future derivatives disable backtracking simulation too
for (int i = 0; i < transitions.Count; ++i)
{
var (node, effects) = transitions[i];
Debug.Assert(node._kind != SymbolicRegexNodeKind.DisableBacktrackingSimulation);
transitions[i] = (_builder.CreateDisableBacktrackingSimulation(node), effects);
}
}
else
{
AddTransitions(elem, context, transitions, new List<SymbolicRegexNode<S>>(), new Stack<DerivativeEffect>(), simulateBacktracking: true);
}
return transitions;
}
/// <summary>
/// Base function used to implement derivative functions. Given an element and a context this will add all patterns
/// whose union makes up the derivative to the given <paramref name="transitions"/> list. If the <paramref name="effects"/>
/// stack is null, then effects are not tracked and all effects arrays in the result will be null. Transitions are added
/// in an order that is consistent with backtracking.
/// </summary>
/// <param name="elem">given element wrt which the derivative is taken</param>
/// <param name="context">immediately surrounding character context that affects nullability of anchors</param>
/// <param name="transitions">a list to add transitions to</param>
/// <param name="continuation">a list used in recursive calls to track nodes to concatenate, should be an empty list at the root call</param>
/// <param name="effects">a stack used in recursive calls to track effects, should be an empty stack at the root call</param>
/// <param name="simulateBacktracking">whether the derivative should only consider paths that backtracking would take, true by default</param>
private void AddTransitions(S elem, uint context, List<(SymbolicRegexNode<S>, DerivativeEffect[])> transitions,
List<SymbolicRegexNode<S>> continuation, Stack<DerivativeEffect>? effects, bool simulateBacktracking)
{
// Helper function for concatenating a head node and a list of continuation nodes. The continuation nodes
// are added in reverse order and the function below uses the list as a stack, so the nodes added to the
// stack first end up at the tail of the concatenation.
static SymbolicRegexNode<S> BuildLeaf(SymbolicRegexNode<S> head, List<SymbolicRegexNode<S>> continuation)
{
SymbolicRegexNode<S> leaf = head._builder.Epsilon;
for (int i = 0; i < continuation.Count; ++i)
{
leaf = head._builder.CreateConcat(continuation[i], leaf);
}
return head._builder.CreateConcat(head, leaf);
}
// Helper function for detecting when an unconditionally nullable pattern is in the transitions and no
// more transitions need to be considered. If the derivative simulates backtracking, then in the next
// step nothing after an unconditionally nullable state would be considered.
// For example, d_a( a|ab ) under backtracking simulation transitions to just epsilon, while without
// backtracking simulation it would transition to epsilon|b.
// All parts of the function below should consider IsDone and return early when it is true.
static bool IsDone(List<(SymbolicRegexNode<S> Node, DerivativeEffect[])> transitions, bool simulateBacktracking) =>
simulateBacktracking && transitions.Count > 0 && transitions[transitions.Count - 1].Node.IsNullable;
// Nothing and epsilon can't consume a character so they generate no transition
if (IsNothing || IsEpsilon)
{
return;
}
// For both .* and .+ the derivative is .* for any character
if (IsAnyStar || IsAnyPlus)
{
Debug.Assert(!IsDone(transitions, simulateBacktracking));
SymbolicRegexNode<S> leaf = BuildLeaf(_builder._anyStar, continuation);
transitions.Add((leaf, effects?.ToArray() ?? Array.Empty<DerivativeEffect>()));
// Signal early exit if the leaf is unconditionally nullable
return;
}
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
StackHelper.CallOnEmptyStack(AddTransitions, elem, context, transitions, continuation, effects, simulateBacktracking);
return;
}
switch (_kind)
{
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(!IsDone(transitions, simulateBacktracking));
Debug.Assert(_set is not null);
// The following check assumes that either (1) the element and predicate are minterms, in which case
// the element is exactly the predicate if the intersection is satisfiable, or (2) the element is a singleton
// set in which case it is fully contained in the predicate if the intersection is satisfiable.
if (_builder._solver.IsSatisfiable(_builder._solver.And(elem, _set)))
{
SymbolicRegexNode<S> leaf = BuildLeaf(_builder.Epsilon, continuation);
transitions.Add((leaf, effects?.ToArray() ?? Array.Empty<DerivativeEffect>()));
// Signal early exit if the leaf is unconditionally nullable
return;
}
break;
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
if (!_left.IsNullableFor(context))
{
// If the left side can't be nullable then the character must be consumed there.
// For example, d(ab) = d(a)b.
continuation.Add(_right);
_left.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
continuation.RemoveAt(continuation.Count - 1);
}
else if (_left._kind == SymbolicRegexNodeKind.OrderedOr)
{
Debug.Assert(_left._left is not null && _left._right is not null);
// The case of a concatenation with an alternation on the left side, i.e. (R|T)S, is handled
// separately by applying the rewrite to push the concatenation in, i.e. (R|T)S -> RS|TS.
// This is done to support the rule for concatenations with a lazy loop on the left side,
// i.e. R{m,n}?T, which have to be handled as part of the concatenation case to properly order
// the paths in a way that matches the backtracking engines preference. By pushing the
// concatenation into the alternation any loops inside the alternation are guaranteed to show up
// directly on the left side of a concatenation.
// This pattern is for the path where the backtracking matcher would find the match from the first alternative
SymbolicRegexNode<S> leftLeftPath = _builder.CreateConcat(_left._left, _right);
// The backtracking-simulating derivative of the left path will be used when the pattern is nullable,
// i.e. the backtracking matcher would end the match rather than go onto paths in the second
// alternative. When the path through the first alternative is not nullable or the derivative is not
// backtracking-simulating, then all paths through it are considered.
bool leftLeftSimulateBacktracking = simulateBacktracking && leftLeftPath.IsNullableFor(context);
leftLeftPath.AddTransitions(elem, context, transitions, continuation, effects, leftLeftSimulateBacktracking);
// Include the path through the right side only if the left side is not nullable or the derivative
// is not simulating backtracking.
// For example, d( (a|b)c* ) = d(ac) | d(bc), while on the other hand d( (a?|b)c* ) = d(a?c*).
// In the latter case the second alternative is omitted because the backtracking matcher would rather
// accept an empty string for a?c* than anything for bc*.
if (!IsDone(transitions, simulateBacktracking) && !leftLeftSimulateBacktracking)
_builder.CreateConcat(_left._right, _right).AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
}
else
{
// Helper function for the case where the right side consumes the character
static void RightTransition(SymbolicRegexNode<S> node, S elem, uint context, List<(SymbolicRegexNode<S>, DerivativeEffect[])> transitions,
List<SymbolicRegexNode<S>> continuation, Stack<DerivativeEffect>? effects, bool simulateBacktracking)
{
Debug.Assert(node._left is not null && node._right is not null);
// Remember current number of effects so that we know how many to pop
int oldEffectsCount = effects?.Count ?? 0;
if (effects is not null)
{
// Push all effects onto the effects stack
node._left.ApplyEffects((effect, stack) => stack.Push(effect), context, effects);
}
node._right.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
if (effects is not null)
{
// Pop all effects that were added here
while (effects.Count > oldEffectsCount)
effects.Pop();
}
}
// Helper function for the case where the left side consumes the character
static void LeftTransition(SymbolicRegexNode<S> node, S elem, uint context, List<(SymbolicRegexNode<S>, DerivativeEffect[])> transitions,
List<SymbolicRegexNode<S>> continuation, Stack<DerivativeEffect>? effects, bool simulateBacktracking)
{
Debug.Assert(node._left is not null && node._right is not null);
continuation.Add(node._right);
// Disable backtracking simulation for the left side if the right side is not nullable here.
// The intuition is that if the right side is not nullable, then backtracking would not accept the empty
// string here even when it hits a nullable path for the left side, so all paths through the left side
// need to be considered.
bool leftSimulateBacktracking = simulateBacktracking && node._right.IsNullableFor(context);
node._left.AddTransitions(elem, context, transitions, continuation, effects, leftSimulateBacktracking);
continuation.RemoveAt(continuation.Count - 1);
}
// Order the transitions. If the left side is a lazy loop that is nullable due to its lower bound then prefer the right side.
// This is done to match the order that backtracking engines would explore different alternatives, where for a lazy loop
// matches that consume as few characters into the loop as possible are preferred.
// For example, d(a*?b) = d(b) | d(a*?)b while without the lazy loop d(a*b) = d(a*)b | d(b).
if (_left._kind == SymbolicRegexNodeKind.Loop && _left.IsLazy && _left._lower == 0)
{
RightTransition(this, elem, context, transitions, continuation, effects, simulateBacktracking);
if (!IsDone(transitions, simulateBacktracking))
LeftTransition(this, elem, context, transitions, continuation, effects, simulateBacktracking);
}
else
{
LeftTransition(this, elem, context, transitions, continuation, effects, simulateBacktracking);
if (!IsDone(transitions, simulateBacktracking))
RightTransition(this, elem, context, transitions, continuation, effects, simulateBacktracking);
}
}
break;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
Debug.Assert(_upper > 0);
// Add transitions only when the backtracking engines would prefer to enter the loop
if (!simulateBacktracking || !IsLazy || _lower != 0)
{
// The loop derivative peels out one iteration and concatenates the body's derivative with the decremented loop,
// so d(R{m,n}) = d(R)R{max(0,m-1),n-1}. Note that n is guaranteed to be greater than zero, since otherwise the
// loop would have been simplified to nothing, and int.MaxValue is treated as infinity.
int newupper = _upper == int.MaxValue ? int.MaxValue : _upper - 1;
int newlower = _lower == 0 ? 0 : _lower - 1;
SymbolicRegexNode<S> rest = _builder.CreateLoop(_left, IsLazy, newlower, newupper);
continuation.Add(rest);
_left.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
continuation.RemoveAt(continuation.Count - 1);
}
break;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
// The backtracking derivative for the first alternative will be used when it is nullable, i.e. the
// backtracking matcher would end the match rather than go onto paths in the right side. When
// the path through the left side is not nullable or the derivative doesn't simulate backtracking,
// then all paths through it are considered.
bool leftSimulateBacktracking = simulateBacktracking && _left.IsNullableFor(context);
_left.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking && _left.IsNullableFor(context));
// Include the path through the right side only if the left side is not nullable or the derivative
// is not simulating backtracking.
// For example, d(a|b) = d(a) | d(b) while d(a*|b) = d(a*).
if (!IsDone(transitions, simulateBacktracking) && !leftSimulateBacktracking)
_right.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
break;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Fail($"{nameof(AddTransitions)}: DisableBacktrackingSimulation should have been handled outside this function.");
break;
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
foreach (SymbolicRegexNode<S> alt in _alts)
{
alt.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
}
break;
case SymbolicRegexNodeKind.And:
case SymbolicRegexNodeKind.Not:
Debug.Fail($"{nameof(AddTransitions)}:{_kind}");
break;
}
}
/// <summary>
/// Find all effects under this node and supply them to the callback.
/// </summary>
/// <remarks>
/// The construction follows the paths that the backtracking matcher would take. For example in ()|() only the
/// effects for the first alternative will be included.
/// </remarks>
/// <param name="apply">action called for each effect</param>
/// <param name="context">the current context to determine nullability</param>
/// <param name="arg">an additional argument passed through to all callbacks</param>
internal void ApplyEffects<TArg>(Action<DerivativeEffect, TArg> apply, uint context, TArg arg)
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
StackHelper.CallOnEmptyStack(ApplyEffects, apply, context, arg);
return;
}
switch (_kind)
{
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
Debug.Assert(_left.IsNullableFor(context) && _right.IsNullableFor(context));
_left.ApplyEffects(apply, context, arg);
_right.ApplyEffects(apply, context, arg);
break;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
// Apply effect when backtracking engine would enter loop
if (_lower != 0 || (_upper != 0 && !IsLazy && _left.IsNullableFor(context)))
{
Debug.Assert(_left.IsNullableFor(context));
_left.ApplyEffects(apply, context, arg);
}
break;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
if (_left.IsNullableFor(context))
{
// Prefer the left side
_left.ApplyEffects(apply, context, arg);
}
else
{
// Otherwise right side must be nullable
Debug.Assert(_right.IsNullableFor(context));
_right.ApplyEffects(apply, context, arg);
}
break;
case SymbolicRegexNodeKind.CaptureStart:
apply(new DerivativeEffect(DerivativeEffectKind.CaptureStart, _lower), arg);
break;
case SymbolicRegexNodeKind.CaptureEnd:
apply(new DerivativeEffect(DerivativeEffectKind.CaptureEnd, _lower), arg);
break;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
_left.ApplyEffects(apply, context, arg);
break;
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
foreach (SymbolicRegexNode<S> elem in _alts)
{
if (elem.IsNullableFor(context))
elem.ApplyEffects(apply, context, arg);
}
break;
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
foreach (SymbolicRegexNode<S> elem in _alts)
{
Debug.Assert(elem.IsNullableFor(context));
elem.ApplyEffects(apply, context, arg);
}
break;
}
}
#if DEBUG
/// <summary>
/// Computes the closure of CreateDerivative, by exploring all the leaves
/// of the transition regex until no more new leaves are found.
/// Converts the resulting transition system into a symbolic NFA.
/// If the exploration remains incomplete due to the given state bound
/// being reached then the InComplete property of the constructed NFA is true.
/// </summary>
internal SymbolicNFA<S> Explore(int bound) => SymbolicNFA<S>.Explore(this, bound);
/// <summary>Extracts the nullability test as a Boolean combination of anchors</summary>
public SymbolicRegexNode<S> ExtractNullabilityTest()
{
if (IsNullable)
{
return _builder._anyStar;
}
if (!CanBeNullable)
{
return _builder._nothing;
}
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(ExtractNullabilityTest);
}
switch (_kind)
{
case SymbolicRegexNodeKind.BeginningAnchor:
case SymbolicRegexNodeKind.EndAnchor:
case SymbolicRegexNodeKind.BOLAnchor:
case SymbolicRegexNodeKind.EOLAnchor:
case SymbolicRegexNodeKind.BoundaryAnchor:
case SymbolicRegexNodeKind.NonBoundaryAnchor:
case SymbolicRegexNodeKind.EndAnchorZ:
case SymbolicRegexNodeKind.EndAnchorZReverse:
return this;
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
return _builder.And(_left.ExtractNullabilityTest(), _right.ExtractNullabilityTest());
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
SymbolicRegexNode<S> disjunction = _builder._nothing;
foreach (SymbolicRegexNode<S> elem in _alts)
{
disjunction = _builder.Or(disjunction, elem.ExtractNullabilityTest());
}
return disjunction;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
return _builder.OrderedOr(_left.ExtractNullabilityTest(), _right.ExtractNullabilityTest());
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
SymbolicRegexNode<S> conjunction = _builder._anyStar;
foreach (SymbolicRegexNode<S> elem in _alts)
{
conjunction = _builder.And(conjunction, elem.ExtractNullabilityTest());
}
return conjunction;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
return _left.ExtractNullabilityTest();
default:
// All remaining cases could not be nullable or were trivially nullable
// Singleton cannot be nullable and Epsilon and FixedLengthMarker are trivially nullable
Debug.Assert(_kind == SymbolicRegexNodeKind.Not && _left is not null);
return _builder.Not(_left.ExtractNullabilityTest());
}
}
#endif
public override int GetHashCode()
{
return _hashcode;
}
private int ComputeHashCode()
{
switch (_kind)
{
case SymbolicRegexNodeKind.EndAnchor:
case SymbolicRegexNodeKind.BeginningAnchor:
case SymbolicRegexNodeKind.BOLAnchor:
case SymbolicRegexNodeKind.EOLAnchor:
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.BoundaryAnchor:
case SymbolicRegexNodeKind.NonBoundaryAnchor:
case SymbolicRegexNodeKind.EndAnchorZ:
case SymbolicRegexNodeKind.EndAnchorZReverse:
return HashCode.Combine(_kind, _info);
case SymbolicRegexNodeKind.FixedLengthMarker:
case SymbolicRegexNodeKind.CaptureStart:
case SymbolicRegexNodeKind.CaptureEnd:
return HashCode.Combine(_kind, _lower);
case SymbolicRegexNodeKind.Loop:
return HashCode.Combine(_kind, _left, _lower, _upper, _info);
case SymbolicRegexNodeKind.Or or SymbolicRegexNodeKind.And:
return HashCode.Combine(_kind, _alts, _info);
case SymbolicRegexNodeKind.Concat:
case SymbolicRegexNodeKind.OrderedOr:
return HashCode.Combine(_left, _right, _info);
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
return HashCode.Combine(_left, _info);
case SymbolicRegexNodeKind.Singleton:
return HashCode.Combine(_kind, _set);
default:
Debug.Assert(_kind == SymbolicRegexNodeKind.Not);
return HashCode.Combine(_kind, _left, _info);
};
}
public override bool Equals([NotNullWhen(true)] object? obj)
{
if (obj is not SymbolicRegexNode<S> that)
{
return false;
}
if (this == that)
{
return true;
}
if (_kind != that._kind)
{
return false;
}
if (_kind == SymbolicRegexNodeKind.Or)
{
if (_isInternalizedUnion && that._isInternalizedUnion)
{
// Internalized nodes that are not identical are not equal
return false;
}
// Check equality of the sets of regexes
Debug.Assert(_alts is not null && that._alts is not null);
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(_alts.Equals, that._alts);
}
return _alts.Equals(that._alts);
}
return false;
}
private void ToStringForLoop(StringBuilder sb)
{
if (_kind == SymbolicRegexNodeKind.Singleton)
{
ToString(sb);
}
else
{
sb.Append('(');
ToString(sb);
sb.Append(')');
}
}
public override string ToString()
{
StringBuilder sb = new();
ToString(sb);
return sb.ToString();
}
internal void ToString(StringBuilder sb)
{
// Guard against stack overflow due to deep recursion
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
StackHelper.CallOnEmptyStack(ToString, sb);
return;
}
switch (_kind)
{
case SymbolicRegexNodeKind.EndAnchor:
sb.Append("\\z");
return;
case SymbolicRegexNodeKind.BeginningAnchor:
sb.Append("\\A");
return;
case SymbolicRegexNodeKind.BOLAnchor:
sb.Append('^');
return;
case SymbolicRegexNodeKind.EOLAnchor:
sb.Append('$');
return;
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.FixedLengthMarker:
return;
case SymbolicRegexNodeKind.BoundaryAnchor:
sb.Append("\\b");
return;
case SymbolicRegexNodeKind.NonBoundaryAnchor:
sb.Append("\\B");
return;
case SymbolicRegexNodeKind.EndAnchorZ:
sb.Append("\\Z");
return;
case SymbolicRegexNodeKind.EndAnchorZReverse:
sb.Append("\\a");
return;
case SymbolicRegexNodeKind.Or:
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
_alts.ToString(sb);
return;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
_left.ToString(sb);
sb.Append('|');
_right.ToString(sb);
return;
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
_left.ToString(sb);
_right.ToString(sb);
return;
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(_set is not null);
sb.Append(_builder._solver.PrettyPrint(_set));
return;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
if (IsAnyStar)
{
sb.Append(".*");
}
else if (_lower == 0 && _upper == 1)
{
_left.ToStringForLoop(sb);
sb.Append('?');
}
else if (IsStar)
{
_left.ToStringForLoop(sb);
sb.Append('*');
if (IsLazy)
{
sb.Append('?');
}
}
else if (IsPlus)
{
_left.ToStringForLoop(sb);
sb.Append('+');
if (IsLazy)
{
sb.Append('?');
}
}
else if (_lower == 0 && _upper == 0)
{
sb.Append("()");
}
else
{
_left.ToStringForLoop(sb);
sb.Append('{');
sb.Append(_lower);
if (!IsBoundedLoop)
{
sb.Append(',');
}
else if (_lower != _upper)
{
sb.Append(',');
sb.Append(_upper);
}
sb.Append('}');
if (IsLazy)
sb.Append('?');
}
return;
case SymbolicRegexNodeKind.CaptureStart:
sb.Append('\u230A'); // Left floor
// Include group number as a subscript
Debug.Assert(_lower >= 0);
foreach (char c in _lower.ToString())
{
sb.Append((char)('\u2080' + (c - '0')));
}
return;
case SymbolicRegexNodeKind.CaptureEnd:
// Include group number as a superscript
Debug.Assert(_lower >= 0);
foreach (char c in _lower.ToString())
{
switch (c)
{
case '1':
sb.Append('\u00B9');
break;
case '2':
sb.Append('\u00B2');
break;
case '3':
sb.Append('\u00B3');
break;
default:
sb.Append((char)('\u2070' + (c - '0')));
break;
}
}
sb.Append('\u2309'); // Right ceiling
return;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
_left.ToString(sb);
return;
default:
// Using the operator ~ for complement
Debug.Assert(_kind == SymbolicRegexNodeKind.Not);
Debug.Assert(_left is not null);
sb.Append("~(");
_left.ToString(sb);
sb.Append(')');
return;
}
}
/// <summary>
/// Returns the set of all predicates that occur in the regex or
/// the set containing True if there are no precidates in the regex, e.g., if the regex is "^"
/// </summary>
public HashSet<S> GetPredicates()
{
var predicates = new HashSet<S>();
CollectPredicates_helper(predicates);
return predicates;
}
/// <summary>
/// Collects all predicates that occur in the regex into the given set predicates
/// </summary>
private void CollectPredicates_helper(HashSet<S> predicates)
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
StackHelper.CallOnEmptyStack(CollectPredicates_helper, predicates);
return;
}
switch (_kind)
{
case SymbolicRegexNodeKind.BOLAnchor:
case SymbolicRegexNodeKind.EOLAnchor:
case SymbolicRegexNodeKind.EndAnchorZ:
case SymbolicRegexNodeKind.EndAnchorZReverse:
predicates.Add(_builder._newLinePredicate);
return;
case SymbolicRegexNodeKind.BeginningAnchor:
case SymbolicRegexNodeKind.EndAnchor:
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.FixedLengthMarker:
case SymbolicRegexNodeKind.CaptureStart:
case SymbolicRegexNodeKind.CaptureEnd:
return;
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(_set is not null);
predicates.Add(_set);
return;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
_left.CollectPredicates_helper(predicates);
return;
case SymbolicRegexNodeKind.Or:
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
foreach (SymbolicRegexNode<S> sr in _alts)
{
sr.CollectPredicates_helper(predicates);
}
return;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
_left.CollectPredicates_helper(predicates);
_right.CollectPredicates_helper(predicates);
return;
case SymbolicRegexNodeKind.Concat:
// avoid deep nested recursion over long concat nodes
SymbolicRegexNode<S> conc = this;
while (conc._kind == SymbolicRegexNodeKind.Concat)
{
Debug.Assert(conc._left is not null && conc._right is not null);
conc._left.CollectPredicates_helper(predicates);
conc = conc._right;
}
conc.CollectPredicates_helper(predicates);
return;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
_left.CollectPredicates_helper(predicates);
return;
case SymbolicRegexNodeKind.Not:
Debug.Assert(_left is not null);
_left.CollectPredicates_helper(predicates);
return;
case SymbolicRegexNodeKind.NonBoundaryAnchor:
case SymbolicRegexNodeKind.BoundaryAnchor:
predicates.Add(_builder._wordLetterPredicateForAnchors);
return;
default:
Debug.Fail($"{nameof(CollectPredicates_helper)}:{_kind}");
break;
}
}
/// <summary>
/// Compute all the minterms from the predicates in this regex.
/// If S implements IComparable then sort the result in increasing order.
/// </summary>
public S[] ComputeMinterms()
{
Debug.Assert(typeof(S).IsAssignableTo(typeof(IComparable<S>)));
HashSet<S> predicates = GetPredicates();
List<S> mt = _builder._solver.GenerateMinterms(predicates);
mt.Sort();
return mt.ToArray();
}
/// <summary>
/// Create the reverse of this regex
/// </summary>
public SymbolicRegexNode<S> Reverse()
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(Reverse);
}
switch (_kind)
{
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
return _builder.CreateLoop(_left.Reverse(), IsLazy, _lower, _upper);
case SymbolicRegexNodeKind.Concat:
{
Debug.Assert(_left is not null && _right is not null);
SymbolicRegexNode<S> rev = _left.Reverse();
SymbolicRegexNode<S> rest = _right;
while (rest._kind == SymbolicRegexNodeKind.Concat)
{
Debug.Assert(rest._left is not null && rest._right is not null);
SymbolicRegexNode<S> rev1 = rest._left.Reverse();
rev = _builder.CreateConcat(rev1, rev);
rest = rest._right;
}
SymbolicRegexNode<S> restr = rest.Reverse();
rev = _builder.CreateConcat(restr, rev);
return rev;
}
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
return _builder.Or(_alts.Reverse());
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
return _builder.OrderedOr(_left.Reverse(), _right.Reverse());
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
return _builder.And(_alts.Reverse());
case SymbolicRegexNodeKind.Not:
Debug.Assert(_left is not null);
return _builder.Not(_left.Reverse());
case SymbolicRegexNodeKind.FixedLengthMarker:
// Fixed length markers are omitted in reverse
return _builder.Epsilon;
case SymbolicRegexNodeKind.BeginningAnchor:
// The reverse of BeginningAnchor is EndAnchor
return _builder.EndAnchor;
case SymbolicRegexNodeKind.EndAnchor:
return _builder.BeginningAnchor;
case SymbolicRegexNodeKind.BOLAnchor:
// The reverse of BOLanchor is EOLanchor
return _builder.EolAnchor;
case SymbolicRegexNodeKind.EOLAnchor:
return _builder.BolAnchor;
case SymbolicRegexNodeKind.EndAnchorZ:
// The reversal of the \Z anchor
return _builder.EndAnchorZReverse;
case SymbolicRegexNodeKind.EndAnchorZReverse:
// This can potentially only happen if a reversed regex is reversed again.
// Thus, this case is unreachable here, but included for completeness.
return _builder.EndAnchorZ;
case SymbolicRegexNodeKind.CaptureStart:
return CreateCaptureEnd(_builder, _lower);
case SymbolicRegexNodeKind.CaptureEnd:
return CreateCaptureStart(_builder, _lower);
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
return _builder.CreateDisableBacktrackingSimulation(_left.Reverse());
// Remaining cases map to themselves:
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.Singleton:
case SymbolicRegexNodeKind.BoundaryAnchor:
case SymbolicRegexNodeKind.NonBoundaryAnchor:
default:
return this;
}
}
internal bool StartsWithLoop(int upperBoundLowestValue = 1)
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(StartsWithLoop, upperBoundLowestValue);
}
switch (_kind)
{
case SymbolicRegexNodeKind.Loop:
return (_upper < int.MaxValue) && (_upper > upperBoundLowestValue);
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
return _left.StartsWithLoop(upperBoundLowestValue) || (_left.IsNullable && _right.StartsWithLoop(upperBoundLowestValue));
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
return _alts.StartsWithLoop(upperBoundLowestValue);
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
return _left.StartsWithLoop(upperBoundLowestValue) || _right.StartsWithLoop(upperBoundLowestValue);
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
return _left.StartsWithLoop(upperBoundLowestValue);
default:
return false;
};
}
/// <summary>Get the predicate that covers all elements that make some progress.</summary>
internal S GetStartSet() => _startSet;
/// <summary>Compute the predicate that covers all elements that make some progress.</summary>
private S ComputeStartSet()
{
switch (_kind)
{
// Anchors and () do not contribute to the startset
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.FixedLengthMarker:
case SymbolicRegexNodeKind.EndAnchor:
case SymbolicRegexNodeKind.BeginningAnchor:
case SymbolicRegexNodeKind.BoundaryAnchor:
case SymbolicRegexNodeKind.NonBoundaryAnchor:
case SymbolicRegexNodeKind.EOLAnchor:
case SymbolicRegexNodeKind.EndAnchorZ:
case SymbolicRegexNodeKind.EndAnchorZReverse:
case SymbolicRegexNodeKind.BOLAnchor:
case SymbolicRegexNodeKind.CaptureStart:
case SymbolicRegexNodeKind.CaptureEnd:
return _builder._solver.False;
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(_set is not null);
return _set;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
return _left._startSet;
case SymbolicRegexNodeKind.Concat:
{
Debug.Assert(_left is not null && _right is not null);
S startSet = _left.CanBeNullable ? _builder._solver.Or(_left._startSet, _right._startSet) : _left._startSet;
return startSet;
}
case SymbolicRegexNodeKind.Or:
{
Debug.Assert(_alts is not null);
S startSet = _builder._solver.False;
foreach (SymbolicRegexNode<S> alt in _alts)
{
startSet = _builder._solver.Or(startSet, alt._startSet);
}
return startSet;
}
case SymbolicRegexNodeKind.OrderedOr:
{
Debug.Assert(_left is not null && _right is not null);
return _builder._solver.Or(_left._startSet, _right._startSet);
}
case SymbolicRegexNodeKind.And:
{
Debug.Assert(_alts is not null);
S startSet = _builder._solver.True;
foreach (SymbolicRegexNode<S> alt in _alts)
{
startSet = _builder._solver.And(startSet, alt._startSet);
}
return startSet;
}
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
return _left._startSet;
default:
Debug.Assert(_kind == SymbolicRegexNodeKind.Not);
return _builder._solver.True;
}
}
/// <summary>
/// Returns true if this is a loop with an upper bound
/// </summary>
public bool IsBoundedLoop => _kind == SymbolicRegexNodeKind.Loop && _upper < int.MaxValue;
/// <summary>
/// Replace anchors that are infeasible by [] wrt the given previous character kind and what continuation is possible.
/// </summary>
/// <param name="prevKind">previous character kind</param>
/// <param name="contWithWL">if true the continuation can start with wordletter or stop</param>
/// <param name="contWithNWL">if true the continuation can start with nonwordletter or stop</param>
internal SymbolicRegexNode<S> PruneAnchors(uint prevKind, bool contWithWL, bool contWithNWL)
{
// Guard against stack overflow due to deep recursion
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(PruneAnchors, prevKind, contWithWL, contWithNWL);
}
if (!_info.StartsWithSomeAnchor)
return this;
switch (_kind)
{
case SymbolicRegexNodeKind.BeginningAnchor:
return prevKind == CharKind.BeginningEnd ?
this :
_builder._nothing; //start anchor is only nullable if the previous character is Start
case SymbolicRegexNodeKind.EndAnchorZReverse:
return ((prevKind & CharKind.BeginningEnd) != 0) ?
this :
_builder._nothing; //rev(\Z) is only nullable if the previous characters is Start or the very first \n
case SymbolicRegexNodeKind.BoundaryAnchor:
return (prevKind == CharKind.WordLetter ? contWithNWL : contWithWL) ?
this :
// \b is impossible when the previous character is \w but no continuation matches \W
// or the previous character is \W but no continuation matches \w
_builder._nothing;
case SymbolicRegexNodeKind.NonBoundaryAnchor:
return (prevKind == CharKind.WordLetter ? contWithWL : contWithNWL) ?
this :
// \B is impossible when the previous character is \w but no continuation matches \w
// or the previous character is \W but no continuation matches \W
_builder._nothing;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
SymbolicRegexNode<S> body = _left.PruneAnchors(prevKind, contWithWL, contWithNWL);
return body == _left ?
this :
CreateLoop(_builder, body, _lower, _upper, IsLazy);
case SymbolicRegexNodeKind.Concat:
{
Debug.Assert(_left is not null && _right is not null);
SymbolicRegexNode<S> left1 = _left.PruneAnchors(prevKind, contWithWL, contWithNWL);
SymbolicRegexNode<S> right1 = _left.IsNullable ? _right.PruneAnchors(prevKind, contWithWL, contWithNWL) : _right;
Debug.Assert(left1 is not null && right1 is not null);
return left1 == _left && right1 == _right ?
this :
CreateConcat(_builder, left1, right1);
}
case SymbolicRegexNodeKind.Or:
{
Debug.Assert(_alts != null);
var elements = new SymbolicRegexNode<S>[_alts.Count];
int i = 0;
foreach (SymbolicRegexNode<S> alt in _alts)
{
elements[i++] = alt.PruneAnchors(prevKind, contWithWL, contWithNWL);
}
Debug.Assert(i == elements.Length);
return Or(_builder, elements);
}
case SymbolicRegexNodeKind.OrderedOr:
{
Debug.Assert(_left is not null && _right is not null);
SymbolicRegexNode<S> left1 = _left.PruneAnchors(prevKind, contWithWL, contWithNWL);
SymbolicRegexNode<S> right1 = _right.PruneAnchors(prevKind, contWithWL, contWithNWL);
Debug.Assert(left1 is not null && right1 is not null);
return left1 == _left && right1 == _right ?
this :
OrderedOr(_builder, left1, right1);
}
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
SymbolicRegexNode<S> child = _left.PruneAnchors(prevKind, contWithWL, contWithNWL);
return child == _left ?
this :
_builder.CreateDisableBacktrackingSimulation(child);
default:
return this;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Threading;
namespace System.Text.RegularExpressions.Symbolic
{
/// <summary>Represents an AST node of a symbolic regex.</summary>
internal sealed class SymbolicRegexNode<S> where S : notnull
{
internal const string EmptyCharClass = "[]";
/// <summary>Some byte other than 0 to represent true</summary>
internal const byte TrueByte = 1;
/// <summary>Some byte other than 0 to represent false</summary>
internal const byte FalseByte = 2;
/// <summary>The undefined value is the default value 0</summary>
internal const byte UndefinedByte = 0;
internal readonly SymbolicRegexBuilder<S> _builder;
internal readonly SymbolicRegexNodeKind _kind;
internal readonly int _lower;
internal readonly int _upper;
internal readonly S? _set;
internal readonly SymbolicRegexNode<S>? _left;
internal readonly SymbolicRegexNode<S>? _right;
internal readonly SymbolicRegexSet<S>? _alts;
/// <summary>
/// Caches nullability of this node for any given context (0 <= context < ContextLimit)
/// when _info.StartsWithSomeAnchor and _info.CanBeNullable are true. Otherwise the cache is null.
/// </summary>
private byte[]? _nullabilityCache;
private S _startSet;
/// <summary>AST node of a symbolic regex</summary>
/// <param name="builder">the builder</param>
/// <param name="kind">what kind of node</param>
/// <param name="left">left child</param>
/// <param name="right">right child</param>
/// <param name="lower">lower bound of a loop</param>
/// <param name="upper">upper boubd of a loop</param>
/// <param name="set">singelton set</param>
/// <param name="alts">alternatives set of a disjunction or conjunction</param>
/// <param name="info">misc flags including laziness</param>
private SymbolicRegexNode(SymbolicRegexBuilder<S> builder, SymbolicRegexNodeKind kind, SymbolicRegexNode<S>? left, SymbolicRegexNode<S>? right, int lower, int upper, S? set, SymbolicRegexSet<S>? alts, SymbolicRegexInfo info)
{
_builder = builder;
_kind = kind;
_left = left;
_right = right;
_lower = lower;
_upper = upper;
_set = set;
_alts = alts;
_info = info;
_hashcode = ComputeHashCode();
_startSet = ComputeStartSet();
_nullabilityCache = info.StartsWithSomeAnchor && info.CanBeNullable ? new byte[CharKind.ContextLimit] : null;
}
private bool _isInternalizedUnion;
/// <summary> Create a new node or retrieve one from the builder _nodeCache</summary>
private static SymbolicRegexNode<S> Create(SymbolicRegexBuilder<S> builder, SymbolicRegexNodeKind kind, SymbolicRegexNode<S>? left, SymbolicRegexNode<S>? right, int lower, int upper, S? set, SymbolicRegexSet<S>? alts, SymbolicRegexInfo info)
{
SymbolicRegexNode<S>? node;
var key = (kind, left, right, lower, upper, set, alts, info);
if (!builder._nodeCache.TryGetValue(key, out node))
{
// Do not internalize top level Or-nodes or else NFA mode will become ineffective
if (kind == SymbolicRegexNodeKind.Or)
{
node = new(builder, kind, left, right, lower, upper, set, alts, info);
return node;
}
left = left == null || left._kind != SymbolicRegexNodeKind.Or || left._isInternalizedUnion ? left : Internalize(left);
right = right == null || right._kind != SymbolicRegexNodeKind.Or || right._isInternalizedUnion ? right : Internalize(right);
node = new(builder, kind, left, right, lower, upper, set, alts, info);
builder._nodeCache[key] = node;
}
Debug.Assert(node is not null);
return node;
}
/// <summary> Internalize an Or-node that is not yet internalized</summary>
private static SymbolicRegexNode<S> Internalize(SymbolicRegexNode<S> node)
{
Debug.Assert(node._kind == SymbolicRegexNodeKind.Or && !node._isInternalizedUnion);
(SymbolicRegexNodeKind, SymbolicRegexNode<S>?, SymbolicRegexNode<S>?, int, int, S?, SymbolicRegexSet<S>?, SymbolicRegexInfo) node_key =
(SymbolicRegexNodeKind.Or, null, null, -1, -1, default(S), node._alts, node._info);
SymbolicRegexNode<S>? node1;
if (node._builder._nodeCache.TryGetValue(node_key, out node1))
{
Debug.Assert(node1 is not null && node1._isInternalizedUnion);
return node1;
}
else
{
node._isInternalizedUnion = true;
node._builder._nodeCache[node_key] = node;
return node;
}
}
/// <summary>True if this node only involves lazy loops</summary>
internal bool IsLazy => _info.IsLazy;
/// <summary>True if this node accepts the empty string unconditionally.</summary>
internal bool IsNullable => _info.IsNullable;
/// <summary>True if this node can potentially accept the empty string depending on anchors and immediate context.</summary>
internal bool CanBeNullable
{
get
{
Debug.Assert(_info.CanBeNullable || !_info.IsNullable);
return _info.CanBeNullable;
}
}
internal SymbolicRegexInfo _info;
private readonly int _hashcode;
/// <summary>Converts a Concat or OrderdOr into an array, returns anything else in a singleton array.</summary>
/// <param name="list">a list to insert the elements into, or null to return results in a new list</param>
/// <param name="listKind">kind of node to consider as the list builder</param>
public List<SymbolicRegexNode<S>> ToList(List<SymbolicRegexNode<S>>? list = null, SymbolicRegexNodeKind listKind = SymbolicRegexNodeKind.Concat)
{
Debug.Assert(listKind == SymbolicRegexNodeKind.Concat || listKind == SymbolicRegexNodeKind.OrderedOr);
list ??= new List<SymbolicRegexNode<S>>();
AppendToList(this, list, listKind);
return list;
static void AppendToList(SymbolicRegexNode<S> concat, List<SymbolicRegexNode<S>> list, SymbolicRegexNodeKind listKind)
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
StackHelper.CallOnEmptyStack(AppendToList, concat, list, listKind);
return;
}
SymbolicRegexNode<S> node = concat;
while (node._kind == listKind)
{
Debug.Assert(node._left is not null && node._right is not null);
if (node._left._kind == listKind)
{
AppendToList(node._left, list, listKind);
}
else
{
list.Add(node._left);
}
node = node._right;
}
list.Add(node);
}
}
/// <summary>
/// Relative nullability that takes into account the immediate character context
/// in order to resolve nullability of anchors
/// </summary>
/// <param name="context">kind info for previous and next characters</param>
internal bool IsNullableFor(uint context)
{
// if _nullabilityCache is null then IsNullable==CanBeNullable
// Observe that if IsNullable==true then CanBeNullable==true.
// but when the node does not start with an anchor
// and IsNullable==false then CanBeNullable==false.
return _nullabilityCache is null ?
_info.IsNullable :
WithCache(context);
// Separated out to enable the common case (no nullability cache) to be inlined
// and to avoid zero-init costs for generally unused state.
bool WithCache(uint context)
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(IsNullableFor, context);
}
Debug.Assert(context < CharKind.ContextLimit);
// If nullablity has been computed for the given context then return it
byte b = Volatile.Read(ref _nullabilityCache[context]);
if (b != UndefinedByte)
{
return b == TrueByte;
}
// Otherwise compute the nullability recursively for the given context
bool is_nullable;
switch (_kind)
{
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
is_nullable = _lower == 0 || _left.IsNullableFor(context);
break;
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
is_nullable = _left.IsNullableFor(context) && _right.IsNullableFor(context);
break;
case SymbolicRegexNodeKind.Or:
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
is_nullable = _alts.IsNullableFor(context);
break;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
is_nullable = _left.IsNullableFor(context) || _right.IsNullableFor(context);
break;
case SymbolicRegexNodeKind.Not:
Debug.Assert(_left is not null);
is_nullable = !_left.IsNullableFor(context);
break;
case SymbolicRegexNodeKind.BeginningAnchor:
is_nullable = CharKind.Prev(context) == CharKind.BeginningEnd;
break;
case SymbolicRegexNodeKind.EndAnchor:
is_nullable = CharKind.Next(context) == CharKind.BeginningEnd;
break;
case SymbolicRegexNodeKind.BOLAnchor:
// Beg-Of-Line anchor is nullable when the previous character is Newline or Start
// note: at least one of the bits must be 1, but both could also be 1 in case of very first newline
is_nullable = (CharKind.Prev(context) & CharKind.NewLineS) != 0;
break;
case SymbolicRegexNodeKind.EOLAnchor:
// End-Of-Line anchor is nullable when the next character is Newline or Stop
// note: at least one of the bits must be 1, but both could also be 1 in case of \Z
is_nullable = (CharKind.Next(context) & CharKind.NewLineS) != 0;
break;
case SymbolicRegexNodeKind.BoundaryAnchor:
// test that prev char is word letter iff next is not not word letter
is_nullable = ((CharKind.Prev(context) & CharKind.WordLetter) ^ (CharKind.Next(context) & CharKind.WordLetter)) != 0;
break;
case SymbolicRegexNodeKind.NonBoundaryAnchor:
// test that prev char is word letter iff next is word letter
is_nullable = ((CharKind.Prev(context) & CharKind.WordLetter) ^ (CharKind.Next(context) & CharKind.WordLetter)) == 0;
break;
case SymbolicRegexNodeKind.EndAnchorZ:
// \Z anchor is nullable when the next character is either the last Newline or Stop
// note: CharKind.NewLineS == CharKind.Newline|CharKind.StartStop
is_nullable = (CharKind.Next(context) & CharKind.BeginningEnd) != 0;
break;
case SymbolicRegexNodeKind.CaptureStart:
case SymbolicRegexNodeKind.CaptureEnd:
is_nullable = true;
break;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
is_nullable = _left.IsNullableFor(context);
break;
default:
// SymbolicRegexNodeKind.EndAnchorZReverse:
// EndAnchorZRev (rev(\Z)) anchor is nullable when the prev character is either the first Newline or Start
// note: CharKind.NewLineS == CharKind.Newline|CharKind.StartStop
Debug.Assert(_kind == SymbolicRegexNodeKind.EndAnchorZReverse);
is_nullable = (CharKind.Prev(context) & CharKind.BeginningEnd) != 0;
break;
}
Volatile.Write(ref _nullabilityCache[context], is_nullable ? TrueByte : FalseByte);
return is_nullable;
}
}
/// <summary>Returns true if this is equivalent to .* (the node must be eager also)</summary>
public bool IsAnyStar
{
get
{
if (IsStar)
{
Debug.Assert(_left is not null);
if (_left._kind == SymbolicRegexNodeKind.Singleton)
{
Debug.Assert(_left._set is not null);
return !IsLazy && _builder._solver.True.Equals(_left._set);
}
}
return false;
}
}
/// <summary>Returns true if this is equivalent to .+ (the node must be eager also)</summary>
public bool IsAnyPlus
{
get
{
if (IsPlus)
{
Debug.Assert(_left is not null);
if (_left._kind == SymbolicRegexNodeKind.Singleton)
{
Debug.Assert(_left._set is not null);
return !IsLazy && _builder._solver.True.Equals(_left._set);
}
}
return false;
}
}
/// <summary>Returns true if this is equivalent to [\0-\xFFFF] </summary>
public bool IsAnyChar
{
get
{
if (_kind == SymbolicRegexNodeKind.Singleton)
{
Debug.Assert(_set is not null);
return _builder._solver.AreEquivalent(_builder._solver.True, _set);
}
return false;
}
}
/// <summary>Returns true if this is equivalent to [0-[0]]</summary>
public bool IsNothing
{
get
{
if (_kind == SymbolicRegexNodeKind.Singleton)
{
Debug.Assert(_set is not null);
return !_builder._solver.IsSatisfiable(_set);
}
return false;
}
}
/// <summary>Returns true iff this is a loop whose lower bound is 0 and upper bound is max</summary>
public bool IsStar => _lower == 0 && _upper == int.MaxValue;
/// <summary>Returns true if this is Epsilon</summary>
public bool IsEpsilon => _kind == SymbolicRegexNodeKind.Epsilon;
/// <summary>Gets the kind of the regex</summary>
internal SymbolicRegexNodeKind Kind => _kind;
/// <summary>
/// Returns true iff this is a loop whose lower bound is 1 and upper bound is max
/// </summary>
public bool IsPlus => _lower == 1 && _upper == int.MaxValue;
#region called only once, in the constructor of SymbolicRegexBuilder
internal static SymbolicRegexNode<S> CreateFalse(SymbolicRegexBuilder<S> builder) =>
Create(builder, SymbolicRegexNodeKind.Singleton, null, null, -1, -1, builder._solver.False, null, SymbolicRegexInfo.Create());
internal static SymbolicRegexNode<S> CreateTrue(SymbolicRegexBuilder<S> builder) =>
Create(builder, SymbolicRegexNodeKind.Singleton, null, null, -1, -1, builder._solver.True, null, SymbolicRegexInfo.Create(containsSomeCharacter: true));
internal static SymbolicRegexNode<S> CreateFixedLengthMarker(SymbolicRegexBuilder<S> builder, int length) =>
Create(builder, SymbolicRegexNodeKind.FixedLengthMarker, null, null, length, -1, default, null, SymbolicRegexInfo.Create(isAlwaysNullable: true));
internal static SymbolicRegexNode<S> CreateEpsilon(SymbolicRegexBuilder<S> builder) =>
Create(builder, SymbolicRegexNodeKind.Epsilon, null, null, -1, -1, default, null, SymbolicRegexInfo.Create(isAlwaysNullable: true));
internal static SymbolicRegexNode<S> CreateEagerEmptyLoop(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> body) =>
Create(builder, SymbolicRegexNodeKind.Loop, body, null, 0, 0, default, null, SymbolicRegexInfo.Create(isAlwaysNullable: true, isLazy: false));
internal static SymbolicRegexNode<S> CreateBeginEndAnchor(SymbolicRegexBuilder<S> builder, SymbolicRegexNodeKind kind)
{
Debug.Assert(kind is
SymbolicRegexNodeKind.BeginningAnchor or SymbolicRegexNodeKind.EndAnchor or
SymbolicRegexNodeKind.EndAnchorZ or SymbolicRegexNodeKind.EndAnchorZReverse or
SymbolicRegexNodeKind.EOLAnchor or SymbolicRegexNodeKind.BOLAnchor);
return Create(builder, kind, null, null, -1, -1, default, null, SymbolicRegexInfo.Create(startsWithLineAnchor: true, canBeNullable: true));
}
internal static SymbolicRegexNode<S> CreateBoundaryAnchor(SymbolicRegexBuilder<S> builder, SymbolicRegexNodeKind kind)
{
Debug.Assert(kind is SymbolicRegexNodeKind.BoundaryAnchor or SymbolicRegexNodeKind.NonBoundaryAnchor);
return Create(builder, kind, null, null, -1, -1, default, null, SymbolicRegexInfo.Create(startsWithBoundaryAnchor: true, canBeNullable: true));
}
#endregion
internal static SymbolicRegexNode<S> CreateSingleton(SymbolicRegexBuilder<S> builder, S set) =>
Create(builder, SymbolicRegexNodeKind.Singleton, null, null, -1, -1, set, null, SymbolicRegexInfo.Create(containsSomeCharacter: !set.Equals(builder._solver.False)));
internal static SymbolicRegexNode<S> CreateLoop(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> body, int lower, int upper, bool isLazy)
{
Debug.Assert(lower >= 0 && lower <= upper);
return Create(builder, SymbolicRegexNodeKind.Loop, body, null, lower, upper, default, null, SymbolicRegexInfo.Loop(body._info, lower, isLazy));
}
internal static SymbolicRegexNode<S> Or(SymbolicRegexBuilder<S> builder, params SymbolicRegexNode<S>[] disjuncts) =>
CreateCollection(builder, SymbolicRegexNodeKind.Or, SymbolicRegexSet<S>.CreateMulti(builder, disjuncts, SymbolicRegexNodeKind.Or), SymbolicRegexInfo.Or(GetInfos(disjuncts)));
internal static SymbolicRegexNode<S> Or(SymbolicRegexBuilder<S> builder, SymbolicRegexSet<S> disjuncts)
{
Debug.Assert(disjuncts._kind == SymbolicRegexNodeKind.Or || disjuncts.IsEverything);
return CreateCollection(builder, SymbolicRegexNodeKind.Or, disjuncts, SymbolicRegexInfo.Or(GetInfos(disjuncts)));
}
internal static SymbolicRegexNode<S> And(SymbolicRegexBuilder<S> builder, params SymbolicRegexNode<S>[] conjuncts) =>
CreateCollection(builder, SymbolicRegexNodeKind.And, SymbolicRegexSet<S>.CreateMulti(builder, conjuncts, SymbolicRegexNodeKind.And), SymbolicRegexInfo.And(GetInfos(conjuncts)));
internal static SymbolicRegexNode<S> And(SymbolicRegexBuilder<S> builder, SymbolicRegexSet<S> conjuncts)
{
Debug.Assert(conjuncts.IsNothing || conjuncts._kind == SymbolicRegexNodeKind.And);
return CreateCollection(builder, SymbolicRegexNodeKind.And, conjuncts, SymbolicRegexInfo.And(GetInfos(conjuncts)));
}
internal static SymbolicRegexNode<S> CreateCaptureStart(SymbolicRegexBuilder<S> builder, int captureNum) =>
Create(builder, SymbolicRegexNodeKind.CaptureStart, null, null, captureNum, -1, default, null, SymbolicRegexInfo.Create(isAlwaysNullable: true));
internal static SymbolicRegexNode<S> CreateCaptureEnd(SymbolicRegexBuilder<S> builder, int captureNum) =>
Create(builder, SymbolicRegexNodeKind.CaptureEnd, null, null, captureNum, -1, default, null, SymbolicRegexInfo.Create(isAlwaysNullable: true));
internal static SymbolicRegexNode<S> CreateDisableBacktrackingSimulation(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> child) =>
Create(builder, SymbolicRegexNodeKind.DisableBacktrackingSimulation, child, null, -1, -1, default, null, child._info);
private static SymbolicRegexNode<S> CreateCollection(SymbolicRegexBuilder<S> builder, SymbolicRegexNodeKind kind, SymbolicRegexSet<S> alts, SymbolicRegexInfo info) =>
alts.IsNothing ? builder._nothing :
alts.IsEverything ? builder._anyStar :
alts.IsSingleton ? alts.GetSingletonElement() :
Create(builder, kind, null, null, -1, -1, default, alts, info);
private static SymbolicRegexInfo[] GetInfos(SymbolicRegexNode<S>[] nodes)
{
var infos = new SymbolicRegexInfo[nodes.Length];
for (int i = 0; i < nodes.Length; i++)
{
infos[i] = nodes[i]._info;
}
return infos;
}
private static SymbolicRegexInfo[] GetInfos(SymbolicRegexSet<S> nodes)
{
var infos = new SymbolicRegexInfo[nodes.Count];
int i = 0;
foreach (SymbolicRegexNode<S> node in nodes)
{
Debug.Assert(i < nodes.Count);
infos[i++] = node._info;
}
Debug.Assert(i == nodes.Count);
return infos;
}
/// <summary>Make a concatenation of the supplied regex nodes.</summary>
internal static SymbolicRegexNode<S> CreateConcat(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> left, SymbolicRegexNode<S> right)
{
// Concatenating anything with a nothing means the entire concatenation can't match
if (left == builder._nothing || right == builder._nothing)
return builder._nothing;
// If the left or right is empty, just return the other.
if (left.IsEpsilon)
return right;
if (right.IsEpsilon)
return left;
// If the left isn't a concatenation, then proceed to concatenation the left with the right.
if (left._kind != SymbolicRegexNodeKind.Concat)
{
return Create(builder, SymbolicRegexNodeKind.Concat, left, right, -1, -1, default, null, SymbolicRegexInfo.Concat(left._info, right._info));
}
// The left is a concatenation. We want to flatten it out and maintain a right-associative form.
SymbolicRegexNode<S> concat = right;
List<SymbolicRegexNode<S>> leftNodes = left.ToList();
for (int i = leftNodes.Count - 1; i >= 0; i--)
{
concat = Create(builder, SymbolicRegexNodeKind.Concat, leftNodes[i], concat, -1, -1, default, null, SymbolicRegexInfo.Concat(leftNodes[i]._info, concat._info));
}
return concat;
}
/// <summary>
/// Make an ordered or of given regexes, eliminate nothing regexes and treat .* as consuming element.
/// Keep the or flat, assuming both right and left are flat.
/// Apply a counber subsumption/combining optimization, such that e.g. a{2,5}|a{3,10} will be combined to a{2,10}.
/// </summary>
internal static SymbolicRegexNode<S> OrderedOr(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> left, SymbolicRegexNode<S> right, bool deduplicated = false)
{
if (left.IsAnyStar || right == builder._nothing || left == right)
return left;
if (left == builder._nothing)
return right;
// If left is not an Or, try to avoid allocation by checking if deduplication is necessary
if (!deduplicated && left._kind != SymbolicRegexNodeKind.OrderedOr)
{
SymbolicRegexNode<S> current = right;
// Initially assume there are no duplicates
deduplicated = true;
while (current._kind == SymbolicRegexNodeKind.OrderedOr)
{
Debug.Assert(current._left is not null && current._right is not null);
// All Ors are supposed to be in a right associative normal form
Debug.Assert(current._left._kind != SymbolicRegexNodeKind.OrderedOr);
if (current._left == left)
{
// Duplicate found, mark that and exit early
deduplicated = false;
break;
}
current = current._right;
}
// If the loop above got to the end, current is the last element. Check that too
if (deduplicated)
deduplicated = (current != left);
}
if (!deduplicated || left._kind == SymbolicRegexNodeKind.OrderedOr)
{
// If the left side was an or, then it has to be flattened, gather the elements from both sides
List<SymbolicRegexNode<S>> elems = left.ToList(listKind: SymbolicRegexNodeKind.OrderedOr);
int firstRightElem = elems.Count;
right.ToList(elems, listKind: SymbolicRegexNodeKind.OrderedOr);
// Eliminate any duplicate elements, keeping the leftmost element
HashSet<SymbolicRegexNode<S>> seenElems = new();
// Keep track of if any elements from the right side need to be eliminated
bool rightChanged = false;
for (int i = 0; i < elems.Count; i++)
{
if (!seenElems.Contains(elems[i]))
{
seenElems.Add(elems[i]);
}
else
{
// Nothing will be eliminated in the next step
elems[i] = builder._nothing;
rightChanged |= i >= firstRightElem;
}
}
// Build the flattened or, avoiding rebuilding the right side if possible
if (rightChanged)
{
SymbolicRegexNode<S> or = builder._nothing;
for (int i = elems.Count - 1; i >= 0; i--)
{
or = OrderedOr(builder, elems[i], or, deduplicated: true);
}
return or;
}
else
{
SymbolicRegexNode<S> or = right;
for (int i = firstRightElem - 1; i >= 0; i--)
{
or = OrderedOr(builder, elems[i], or, deduplicated: true);
}
return or;
}
}
Debug.Assert(left._kind != SymbolicRegexNodeKind.OrderedOr);
Debug.Assert(deduplicated);
// Apply the counter subsumption/combining optimization if possible
(SymbolicRegexNode<S> loop, SymbolicRegexNode<S> rest) = left.FirstCounterInfo();
if (loop != builder._nothing)
{
Debug.Assert(loop._kind == SymbolicRegexNodeKind.Loop && loop._left is not null);
(SymbolicRegexNode<S> otherLoop, SymbolicRegexNode<S> otherRest) = right.FirstCounterInfo();
if (otherLoop != builder._nothing && rest == otherRest)
{
// Found two adjacent counters with the same continuation, check that the loops are equivalent apart from bounds
// and that the bounds form a contiguous interval. Two integer intervals [x1,x2] and [y1,y2] overlap when
// x1 <= y2 and y1 <= x2. The union of intervals that just touch is still contiguous, e.g. [2,5] and [6,10] make
// [2,10], so the lower bounds are decremented by 1 in the check.
Debug.Assert(otherLoop._kind == SymbolicRegexNodeKind.Loop && otherLoop._left is not null);
if (loop._left == otherLoop._left && loop.IsLazy == otherLoop.IsLazy &&
loop._lower - 1 <= otherLoop._upper && otherLoop._lower - 1 <= loop._upper)
{
// Loops are equivalent apart from bounds, and the union of the bounds is a contiguous interval
// Build a new counter for the union of the ranges
SymbolicRegexNode<S> newCounter = CreateConcat(builder, CreateLoop(builder, loop._left,
Math.Min(loop._lower, otherLoop._lower), Math.Max(loop._upper, otherLoop._upper), loop.IsLazy), rest);
if (right._kind == SymbolicRegexNodeKind.OrderedOr)
{
// The right counter came from an or, so include the rest of that or
Debug.Assert(right._right is not null);
return OrderedOr(builder, newCounter, right._right, deduplicated: true);
}
else
{
return newCounter;
}
}
}
}
// Counter optimization did not apply, just build the or
return Create(builder, SymbolicRegexNodeKind.OrderedOr, left, right, -1, -1, default, null, SymbolicRegexInfo.Or(left._info, right._info));
}
/// <summary>
/// Extract a counter as a loop followed by its continuation. For example, a*b returns (a*,b).
/// Also look into the first element of an or, so a+|xyz returns (a+,()).
/// If no counter is found returns ([],[]).
/// </summary>
/// <returns>a tuple of the loop and its continuation</returns>
private (SymbolicRegexNode<S>, SymbolicRegexNode<S>) FirstCounterInfo()
{
if (_kind == SymbolicRegexNodeKind.Loop)
return (this, _builder.Epsilon);
if (_kind == SymbolicRegexNodeKind.Concat)
{
Debug.Assert(_left is not null && _right is not null);
if (_left.Kind == SymbolicRegexNodeKind.Loop)
return (_left, _right);
}
if (_kind == SymbolicRegexNodeKind.OrderedOr)
{
Debug.Assert(_left is not null);
return _left.FirstCounterInfo();
}
return (_builder._nothing, _builder._nothing);
}
internal static SymbolicRegexNode<S> Not(SymbolicRegexBuilder<S> builder, SymbolicRegexNode<S> root)
{
// Instead of just creating a negated root node
// Convert ~root to Negation Normal Form (NNF) by using deMorgan's laws and push ~ to the leaves
// This may avoid rather large overhead (such case was discovered with unit test PasswordSearchDual)
// Do this transformation in-line without recursion, to avoid any chance of deep recursion
// OBSERVE: NNF[node] represents the Negation Normal Form of ~node
Dictionary<SymbolicRegexNode<S>, SymbolicRegexNode<S>> NNF = new();
Stack<(SymbolicRegexNode<S>, bool)> todo = new();
todo.Push((root, false));
while (todo.Count > 0)
{
(SymbolicRegexNode<S>, bool) top = todo.Pop();
bool secondTimePushed = top.Item2;
SymbolicRegexNode<S> node = top.Item1;
if (secondTimePushed)
{
Debug.Assert((node._kind == SymbolicRegexNodeKind.Or || node._kind == SymbolicRegexNodeKind.And) && node._alts is not null);
// Here all members of _alts have been processed
List<SymbolicRegexNode<S>> alts_nnf = new();
foreach (SymbolicRegexNode<S> elem in node._alts)
{
alts_nnf.Add(NNF[elem]);
}
// Using deMorgan's laws, flip the kind: Or becomes And, And becomes Or
SymbolicRegexNode<S> node_nnf = node._kind == SymbolicRegexNodeKind.Or ? And(builder, alts_nnf.ToArray()) : Or(builder, alts_nnf.ToArray());
NNF[node] = node_nnf;
}
else
{
switch (node._kind)
{
case SymbolicRegexNodeKind.Not:
Debug.Assert(node._left is not null);
// Here we assume that top._left is already in NNF, double negation is cancelled out
NNF[node] = node._left;
break;
case SymbolicRegexNodeKind.Or or SymbolicRegexNodeKind.And:
Debug.Assert(node._alts is not null);
// Push the node for the second time
todo.Push((node, true));
// Compute the negation normal form of all the members
// Their computation is actually the same independent from being inside an 'Or' or 'And' node
foreach (SymbolicRegexNode<S> elem in node._alts)
{
todo.Push((elem, false));
}
break;
case SymbolicRegexNodeKind.Epsilon:
// ~() = .+
NNF[node] = SymbolicRegexNode<S>.CreateLoop(builder, builder._anyChar, 1, int.MaxValue, isLazy: false);
break;
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(node._set is not null);
// ~[] = .*
if (node.IsNothing)
{
NNF[node] = builder._anyStar;
break;
}
goto default;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(node._left is not null);
// ~(.*) = [] and ~(.+) = ()
if (node.IsAnyStar)
{
NNF[node] = builder._nothing;
break;
}
else if (node.IsPlus && node._left.IsAnyChar)
{
NNF[node] = builder.Epsilon;
break;
}
goto default;
default:
// In all other cases construct the complement
NNF[node] = Create(builder, SymbolicRegexNodeKind.Not, node, null, -1, -1, default, null, SymbolicRegexInfo.Not(node._info));
break;
}
}
}
return NNF[root];
}
/// <summary>
/// Returns the fixed matching length of the regex or -1 if the regex does not have a fixed matching length.
/// </summary>
public int GetFixedLength()
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
// If we can't recur further, assume no fixed length.
return -1;
}
switch (_kind)
{
case SymbolicRegexNodeKind.FixedLengthMarker:
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.BOLAnchor:
case SymbolicRegexNodeKind.EOLAnchor:
case SymbolicRegexNodeKind.EndAnchor:
case SymbolicRegexNodeKind.BeginningAnchor:
case SymbolicRegexNodeKind.EndAnchorZ:
case SymbolicRegexNodeKind.EndAnchorZReverse:
case SymbolicRegexNodeKind.BoundaryAnchor:
case SymbolicRegexNodeKind.NonBoundaryAnchor:
case SymbolicRegexNodeKind.CaptureStart:
case SymbolicRegexNodeKind.CaptureEnd:
return 0;
case SymbolicRegexNodeKind.Singleton:
return 1;
case SymbolicRegexNodeKind.Loop:
{
Debug.Assert(_left is not null);
if (_lower == _upper)
{
long length = _left.GetFixedLength();
if (length >= 0)
{
length *= _lower;
if (length <= int.MaxValue)
{
return (int)length;
}
}
}
break;
}
case SymbolicRegexNodeKind.Concat:
{
Debug.Assert(_left is not null && _right is not null);
int leftLength = _left.GetFixedLength();
if (leftLength >= 0)
{
int rightLength = _right.GetFixedLength();
if (rightLength >= 0)
{
long length = (long)leftLength + rightLength;
if (length <= int.MaxValue)
{
return (int)length;
}
}
}
break;
}
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
return _alts.GetFixedLength();
case SymbolicRegexNodeKind.OrderedOr:
{
Debug.Assert(_left is not null && _right is not null);
int length = _left.GetFixedLength();
if (length >= 0)
{
if (_right.GetFixedLength() == length)
{
return length;
}
}
break;
}
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
return _left.GetFixedLength();
}
return -1;
}
#if DEBUG
private TransitionRegex<S>? _transitionRegex;
/// <summary>
/// Computes the symbolic derivative as a transition regex.
/// Transitions are in the tree left to right in the order the backtracking engine would explore them.
/// </summary>
internal TransitionRegex<S> CreateDerivative()
{
if (_transitionRegex is not null)
{
return _transitionRegex;
}
if (IsNothing || IsEpsilon)
{
_transitionRegex = TransitionRegex<S>.Leaf(_builder._nothing);
return _transitionRegex;
}
if (IsAnyStar || IsAnyPlus)
{
_transitionRegex = TransitionRegex<S>.Leaf(_builder._anyStar);
return _transitionRegex;
}
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(CreateDerivative);
}
switch (_kind)
{
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(_set is not null);
_transitionRegex = TransitionRegex<S>.Conditional(_set, TransitionRegex<S>.Leaf(_builder.Epsilon), TransitionRegex<S>.Leaf(_builder._nothing));
break;
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
TransitionRegex<S> mainTransition = _left.CreateDerivative().Concat(_right);
if (!_left.CanBeNullable)
{
// If _left is never nullable
_transitionRegex = mainTransition;
}
else if (_left.IsNullable)
{
// If _left is unconditionally nullable
_transitionRegex = TransitionRegex<S>.Union(mainTransition, _right.CreateDerivative());
}
else
{
// The left side contains anchors and can be nullable in some context
// Extract the nullability as the lookaround condition
SymbolicRegexNode<S> leftNullabilityTest = _left.ExtractNullabilityTest();
_transitionRegex = TransitionRegex<S>.Lookaround(leftNullabilityTest, TransitionRegex<S>.Union(mainTransition, _right.CreateDerivative()), mainTransition);
}
break;
case SymbolicRegexNodeKind.Loop:
// d(R*) = d(R+) = d(R)R*
Debug.Assert(_left is not null);
Debug.Assert(_upper > 0);
TransitionRegex<S> step = _left.CreateDerivative();
if (IsStar || IsPlus)
{
_transitionRegex = step.Concat(_builder.CreateLoop(_left, IsLazy));
}
else
{
int newupper = _upper == int.MaxValue ? int.MaxValue : _upper - 1;
int newlower = _lower == 0 ? 0 : _lower - 1;
SymbolicRegexNode<S> rest = _builder.CreateLoop(_left, IsLazy, newlower, newupper);
_transitionRegex = step.Concat(rest);
}
break;
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
_transitionRegex = TransitionRegex<S>.Leaf(_builder._nothing);
foreach (SymbolicRegexNode<S> elem in _alts)
{
_transitionRegex = TransitionRegex<S>.Union(_transitionRegex, elem.CreateDerivative());
}
break;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
_transitionRegex = TransitionRegex<S>.Union(_left.CreateDerivative(), _right.CreateDerivative());
break;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
// The derivative to TransitionRegex does not support backtracking simulation, so ignore this node
_transitionRegex = _left.CreateDerivative();
break;
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
_transitionRegex = TransitionRegex<S>.Leaf(_builder._anyStar);
foreach (SymbolicRegexNode<S> elem in _alts)
{
_transitionRegex = TransitionRegex<S>.Intersect(_transitionRegex, elem.CreateDerivative());
}
break;
case SymbolicRegexNodeKind.Not:
Debug.Assert(_left is not null);
_transitionRegex = _left.CreateDerivative().Complement();
break;
default:
_transitionRegex = TransitionRegex<S>.Leaf(_builder._nothing);
break;
}
return _transitionRegex;
}
#endif
/// <summary>
/// Takes the derivative of the symbolic regex for the given element, which must be either
/// a minterm (i.e. a class of characters that have identical behavior for all predicates in the pattern)
/// or a singleton set. This derivative simulates backtracking, i.e. it only considers paths that backtracking would
/// take before accepting the empty string for this pattern and returns the pattern ordered in the order backtracking
/// would explore paths. For example the derivative of a*ab for a is a*ab|b, while for a*?ab it is b|a*?ab.
/// </summary>
/// <param name="elem">given element wrt which the derivative is taken</param>
/// <param name="context">immediately surrounding character context that affects nullability of anchors</param>
/// <returns>the derivative</returns>
internal SymbolicRegexNode<S> CreateDerivative(S elem, uint context)
{
List<(SymbolicRegexNode<S> Node, DerivativeEffect[])> transitions = new();
if (_kind == SymbolicRegexNodeKind.DisableBacktrackingSimulation)
{
// Since this node disables backtracking simulation, unwrap the node and pass the corresponding flag as
// false to AddTransitions.
Debug.Assert(_left is not null);
_left.AddTransitions(elem, context, transitions, new List<SymbolicRegexNode<S>>(), null, simulateBacktracking: false);
}
else
{
AddTransitions(elem, context, transitions, new List<SymbolicRegexNode<S>>(), null, simulateBacktracking: true);
}
SymbolicRegexNode<S> derivative = _builder._nothing;
// Iterate backwards to avoid quadratic rebuilding of the Or nodes, which are always simplified to
// right associative form. Concretely:
// In (a|(b|c)) | d -> (a|(b|(c|d)) the first argument is not a subtree of the result.
// In a | (b|(c|d)) -> (a|(b|(c|d)) the second argument is a subtree of the result.
// The first case performs linear work for each element, leading to a quadratic blowup.
for (int i = transitions.Count - 1; i >= 0; --i)
{
SymbolicRegexNode<S> node = transitions[i].Node;
Debug.Assert(node._kind != SymbolicRegexNodeKind.DisableBacktrackingSimulation);
derivative = _builder.OrderedOr(node, derivative);
}
if (_kind == SymbolicRegexNodeKind.DisableBacktrackingSimulation)
// Make future derivatives disable backtracking simulation too
derivative = _builder.CreateDisableBacktrackingSimulation(derivative);
return derivative;
}
/// <summary>
/// Takes the derivative of the symbolic regex for the given element, which must be either
/// a minterm (i.e. a class of characters that have identical behavior for all predicates in the pattern)
/// or a singleton set. This derivative simulates backtracking, i.e. it only considers paths that backtracking would
/// take before accepting the empty string for this pattern and returns the pattern ordered in the order backtracking
/// would explore paths. For example the derivative of a*ab places a*ab before b, while for a*?ab the order is reversed.
/// </summary>
/// <remarks>
/// The differences of this to <see cref="CreateDerivative(S,uint)"/> are that (1) effects (e.g. capture starts and ends)
/// are considered and (2) the different elements that would form a top level union are instead returned as separate
/// nodes (paired with their associated effects). This function is meant to be used for NFA simulation, where top level
/// unions would be broken up into separate states anyway, so nodes are not combined even if they have the same effects.
/// </remarks>
/// <param name="elem">given element wrt which the derivative is taken</param>
/// <param name="context">immediately surrounding character context that affects nullability of anchors</param>
/// <returns>the derivative</returns>
internal List<(SymbolicRegexNode<S>, DerivativeEffect[])> CreateNfaDerivativeWithEffects(S elem, uint context)
{
List<(SymbolicRegexNode<S>, DerivativeEffect[])> transitions = new();
if (_kind == SymbolicRegexNodeKind.DisableBacktrackingSimulation)
{
// Since this node disables backtracking simulation, unwrap the node and pass the corresponding flag as
// false to AddTransitions.
Debug.Assert(_left is not null);
_left.AddTransitions(elem, context, transitions, new List<SymbolicRegexNode<S>>(), new Stack<DerivativeEffect>(), simulateBacktracking: false);
// Make future derivatives disable backtracking simulation too
for (int i = 0; i < transitions.Count; ++i)
{
var (node, effects) = transitions[i];
Debug.Assert(node._kind != SymbolicRegexNodeKind.DisableBacktrackingSimulation);
transitions[i] = (_builder.CreateDisableBacktrackingSimulation(node), effects);
}
}
else
{
AddTransitions(elem, context, transitions, new List<SymbolicRegexNode<S>>(), new Stack<DerivativeEffect>(), simulateBacktracking: true);
}
return transitions;
}
/// <summary>
/// Base function used to implement derivative functions. Given an element and a context this will add all patterns
/// whose union makes up the derivative to the given <paramref name="transitions"/> list. If the <paramref name="effects"/>
/// stack is null, then effects are not tracked and all effects arrays in the result will be null. Transitions are added
/// in an order that is consistent with backtracking.
/// </summary>
/// <param name="elem">given element wrt which the derivative is taken</param>
/// <param name="context">immediately surrounding character context that affects nullability of anchors</param>
/// <param name="transitions">a list to add transitions to</param>
/// <param name="continuation">a list used in recursive calls to track nodes to concatenate, should be an empty list at the root call</param>
/// <param name="effects">a stack used in recursive calls to track effects, should be an empty stack at the root call</param>
/// <param name="simulateBacktracking">whether the derivative should only consider paths that backtracking would take, true by default</param>
private void AddTransitions(S elem, uint context, List<(SymbolicRegexNode<S>, DerivativeEffect[])> transitions,
List<SymbolicRegexNode<S>> continuation, Stack<DerivativeEffect>? effects, bool simulateBacktracking)
{
// Helper function for concatenating a head node and a list of continuation nodes. The continuation nodes
// are added in reverse order and the function below uses the list as a stack, so the nodes added to the
// stack first end up at the tail of the concatenation.
static SymbolicRegexNode<S> BuildLeaf(SymbolicRegexNode<S> head, List<SymbolicRegexNode<S>> continuation)
{
SymbolicRegexNode<S> leaf = head._builder.Epsilon;
for (int i = 0; i < continuation.Count; ++i)
{
leaf = head._builder.CreateConcat(continuation[i], leaf);
}
return head._builder.CreateConcat(head, leaf);
}
// Helper function for detecting when an unconditionally nullable pattern is in the transitions and no
// more transitions need to be considered. If the derivative simulates backtracking, then in the next
// step nothing after an unconditionally nullable state would be considered.
// For example, d_a( a|ab ) under backtracking simulation transitions to just epsilon, while without
// backtracking simulation it would transition to epsilon|b.
// All parts of the function below should consider IsDone and return early when it is true.
static bool IsDone(List<(SymbolicRegexNode<S> Node, DerivativeEffect[])> transitions, bool simulateBacktracking) =>
simulateBacktracking && transitions.Count > 0 && transitions[transitions.Count - 1].Node.IsNullable;
// Nothing and epsilon can't consume a character so they generate no transition
if (IsNothing || IsEpsilon)
{
return;
}
// For both .* and .+ the derivative is .* for any character
if (IsAnyStar || IsAnyPlus)
{
Debug.Assert(!IsDone(transitions, simulateBacktracking));
SymbolicRegexNode<S> leaf = BuildLeaf(_builder._anyStar, continuation);
transitions.Add((leaf, effects?.ToArray() ?? Array.Empty<DerivativeEffect>()));
// Signal early exit if the leaf is unconditionally nullable
return;
}
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
StackHelper.CallOnEmptyStack(AddTransitions, elem, context, transitions, continuation, effects, simulateBacktracking);
return;
}
switch (_kind)
{
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(!IsDone(transitions, simulateBacktracking));
Debug.Assert(_set is not null);
// The following check assumes that either (1) the element and predicate are minterms, in which case
// the element is exactly the predicate if the intersection is satisfiable, or (2) the element is a singleton
// set in which case it is fully contained in the predicate if the intersection is satisfiable.
if (_builder._solver.IsSatisfiable(_builder._solver.And(elem, _set)))
{
SymbolicRegexNode<S> leaf = BuildLeaf(_builder.Epsilon, continuation);
transitions.Add((leaf, effects?.ToArray() ?? Array.Empty<DerivativeEffect>()));
// Signal early exit if the leaf is unconditionally nullable
return;
}
break;
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
if (!_left.IsNullableFor(context))
{
// If the left side can't be nullable then the character must be consumed there.
// For example, d(ab) = d(a)b.
continuation.Add(_right);
_left.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
continuation.RemoveAt(continuation.Count - 1);
}
else if (_left._kind == SymbolicRegexNodeKind.OrderedOr)
{
Debug.Assert(_left._left is not null && _left._right is not null);
// The case of a concatenation with an alternation on the left side, i.e. (R|T)S, is handled
// separately by applying the rewrite to push the concatenation in, i.e. (R|T)S -> RS|TS.
// This is done to support the rule for concatenations with a lazy loop on the left side,
// i.e. R{m,n}?T, which have to be handled as part of the concatenation case to properly order
// the paths in a way that matches the backtracking engines preference. By pushing the
// concatenation into the alternation any loops inside the alternation are guaranteed to show up
// directly on the left side of a concatenation.
// This pattern is for the path where the backtracking matcher would find the match from the first alternative
SymbolicRegexNode<S> leftLeftPath = _builder.CreateConcat(_left._left, _right);
// The backtracking-simulating derivative of the left path will be used when the pattern is nullable,
// i.e. the backtracking matcher would end the match rather than go onto paths in the second
// alternative. When the path through the first alternative is not nullable or the derivative is not
// backtracking-simulating, then all paths through it are considered.
bool leftLeftSimulateBacktracking = simulateBacktracking && leftLeftPath.IsNullableFor(context);
leftLeftPath.AddTransitions(elem, context, transitions, continuation, effects, leftLeftSimulateBacktracking);
// Include the path through the right side only if the left side is not nullable or the derivative
// is not simulating backtracking.
// For example, d( (a|b)c* ) = d(ac) | d(bc), while on the other hand d( (a?|b)c* ) = d(a?c*).
// In the latter case the second alternative is omitted because the backtracking matcher would rather
// accept an empty string for a?c* than anything for bc*.
if (!IsDone(transitions, simulateBacktracking) && !leftLeftSimulateBacktracking)
_builder.CreateConcat(_left._right, _right).AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
}
else
{
// Helper function for the case where the right side consumes the character
static void RightTransition(SymbolicRegexNode<S> node, S elem, uint context, List<(SymbolicRegexNode<S>, DerivativeEffect[])> transitions,
List<SymbolicRegexNode<S>> continuation, Stack<DerivativeEffect>? effects, bool simulateBacktracking)
{
Debug.Assert(node._left is not null && node._right is not null);
// Remember current number of effects so that we know how many to pop
int oldEffectsCount = effects?.Count ?? 0;
if (effects is not null)
{
// Push all effects onto the effects stack
node._left.ApplyEffects((effect, stack) => stack.Push(effect), context, effects);
}
node._right.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
if (effects is not null)
{
// Pop all effects that were added here
while (effects.Count > oldEffectsCount)
effects.Pop();
}
}
// Helper function for the case where the left side consumes the character
static void LeftTransition(SymbolicRegexNode<S> node, S elem, uint context, List<(SymbolicRegexNode<S>, DerivativeEffect[])> transitions,
List<SymbolicRegexNode<S>> continuation, Stack<DerivativeEffect>? effects, bool simulateBacktracking)
{
Debug.Assert(node._left is not null && node._right is not null);
continuation.Add(node._right);
// Disable backtracking simulation for the left side if the right side is not nullable here.
// The intuition is that if the right side is not nullable, then backtracking would not accept the empty
// string here even when it hits a nullable path for the left side, so all paths through the left side
// need to be considered.
bool leftSimulateBacktracking = simulateBacktracking && node._right.IsNullableFor(context);
node._left.AddTransitions(elem, context, transitions, continuation, effects, leftSimulateBacktracking);
continuation.RemoveAt(continuation.Count - 1);
}
// Order the transitions. If the left side is a lazy loop that is nullable due to its lower bound then prefer the right side.
// This is done to match the order that backtracking engines would explore different alternatives, where for a lazy loop
// matches that consume as few characters into the loop as possible are preferred.
// For example, d(a*?b) = d(b) | d(a*?)b while without the lazy loop d(a*b) = d(a*)b | d(b).
if (_left._kind == SymbolicRegexNodeKind.Loop && _left.IsLazy && _left._lower == 0)
{
RightTransition(this, elem, context, transitions, continuation, effects, simulateBacktracking);
if (!IsDone(transitions, simulateBacktracking))
LeftTransition(this, elem, context, transitions, continuation, effects, simulateBacktracking);
}
else
{
LeftTransition(this, elem, context, transitions, continuation, effects, simulateBacktracking);
if (!IsDone(transitions, simulateBacktracking))
RightTransition(this, elem, context, transitions, continuation, effects, simulateBacktracking);
}
}
break;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
Debug.Assert(_upper > 0);
// Add transitions only when the backtracking engines would prefer to enter the loop
if (!simulateBacktracking || !IsLazy || _lower != 0)
{
// The loop derivative peels out one iteration and concatenates the body's derivative with the decremented loop,
// so d(R{m,n}) = d(R)R{max(0,m-1),n-1}. Note that n is guaranteed to be greater than zero, since otherwise the
// loop would have been simplified to nothing, and int.MaxValue is treated as infinity.
int newupper = _upper == int.MaxValue ? int.MaxValue : _upper - 1;
int newlower = _lower == 0 ? 0 : _lower - 1;
SymbolicRegexNode<S> rest = _builder.CreateLoop(_left, IsLazy, newlower, newupper);
continuation.Add(rest);
_left.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
continuation.RemoveAt(continuation.Count - 1);
}
break;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
// The backtracking derivative for the first alternative will be used when it is nullable, i.e. the
// backtracking matcher would end the match rather than go onto paths in the right side. When
// the path through the left side is not nullable or the derivative doesn't simulate backtracking,
// then all paths through it are considered.
bool leftSimulateBacktracking = simulateBacktracking && _left.IsNullableFor(context);
_left.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking && _left.IsNullableFor(context));
// Include the path through the right side only if the left side is not nullable or the derivative
// is not simulating backtracking.
// For example, d(a|b) = d(a) | d(b) while d(a*|b) = d(a*).
if (!IsDone(transitions, simulateBacktracking) && !leftSimulateBacktracking)
_right.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
break;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Fail($"{nameof(AddTransitions)}: DisableBacktrackingSimulation should have been handled outside this function.");
break;
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
foreach (SymbolicRegexNode<S> alt in _alts)
{
alt.AddTransitions(elem, context, transitions, continuation, effects, simulateBacktracking);
}
break;
case SymbolicRegexNodeKind.And:
case SymbolicRegexNodeKind.Not:
Debug.Fail($"{nameof(AddTransitions)}:{_kind}");
break;
}
}
/// <summary>
/// Find all effects under this node and supply them to the callback.
/// </summary>
/// <remarks>
/// The construction follows the paths that the backtracking matcher would take. For example in ()|() only the
/// effects for the first alternative will be included.
/// </remarks>
/// <param name="apply">action called for each effect</param>
/// <param name="context">the current context to determine nullability</param>
/// <param name="arg">an additional argument passed through to all callbacks</param>
internal void ApplyEffects<TArg>(Action<DerivativeEffect, TArg> apply, uint context, TArg arg)
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
StackHelper.CallOnEmptyStack(ApplyEffects, apply, context, arg);
return;
}
switch (_kind)
{
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
Debug.Assert(_left.IsNullableFor(context) && _right.IsNullableFor(context));
_left.ApplyEffects(apply, context, arg);
_right.ApplyEffects(apply, context, arg);
break;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
// Apply effect when backtracking engine would enter loop
if (_lower != 0 || (_upper != 0 && !IsLazy && _left.IsNullableFor(context)))
{
Debug.Assert(_left.IsNullableFor(context));
_left.ApplyEffects(apply, context, arg);
}
break;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
if (_left.IsNullableFor(context))
{
// Prefer the left side
_left.ApplyEffects(apply, context, arg);
}
else
{
// Otherwise right side must be nullable
Debug.Assert(_right.IsNullableFor(context));
_right.ApplyEffects(apply, context, arg);
}
break;
case SymbolicRegexNodeKind.CaptureStart:
apply(new DerivativeEffect(DerivativeEffectKind.CaptureStart, _lower), arg);
break;
case SymbolicRegexNodeKind.CaptureEnd:
apply(new DerivativeEffect(DerivativeEffectKind.CaptureEnd, _lower), arg);
break;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
_left.ApplyEffects(apply, context, arg);
break;
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
foreach (SymbolicRegexNode<S> elem in _alts)
{
if (elem.IsNullableFor(context))
elem.ApplyEffects(apply, context, arg);
}
break;
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
foreach (SymbolicRegexNode<S> elem in _alts)
{
Debug.Assert(elem.IsNullableFor(context));
elem.ApplyEffects(apply, context, arg);
}
break;
}
}
#if DEBUG
/// <summary>
/// Computes the closure of CreateDerivative, by exploring all the leaves
/// of the transition regex until no more new leaves are found.
/// Converts the resulting transition system into a symbolic NFA.
/// If the exploration remains incomplete due to the given state bound
/// being reached then the InComplete property of the constructed NFA is true.
/// </summary>
internal SymbolicNFA<S> Explore(int bound) => SymbolicNFA<S>.Explore(this, bound);
/// <summary>Extracts the nullability test as a Boolean combination of anchors</summary>
public SymbolicRegexNode<S> ExtractNullabilityTest()
{
if (IsNullable)
{
return _builder._anyStar;
}
if (!CanBeNullable)
{
return _builder._nothing;
}
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(ExtractNullabilityTest);
}
switch (_kind)
{
case SymbolicRegexNodeKind.BeginningAnchor:
case SymbolicRegexNodeKind.EndAnchor:
case SymbolicRegexNodeKind.BOLAnchor:
case SymbolicRegexNodeKind.EOLAnchor:
case SymbolicRegexNodeKind.BoundaryAnchor:
case SymbolicRegexNodeKind.NonBoundaryAnchor:
case SymbolicRegexNodeKind.EndAnchorZ:
case SymbolicRegexNodeKind.EndAnchorZReverse:
return this;
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
return _builder.And(_left.ExtractNullabilityTest(), _right.ExtractNullabilityTest());
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
SymbolicRegexNode<S> disjunction = _builder._nothing;
foreach (SymbolicRegexNode<S> elem in _alts)
{
disjunction = _builder.Or(disjunction, elem.ExtractNullabilityTest());
}
return disjunction;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
return _builder.OrderedOr(_left.ExtractNullabilityTest(), _right.ExtractNullabilityTest());
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
SymbolicRegexNode<S> conjunction = _builder._anyStar;
foreach (SymbolicRegexNode<S> elem in _alts)
{
conjunction = _builder.And(conjunction, elem.ExtractNullabilityTest());
}
return conjunction;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
return _left.ExtractNullabilityTest();
default:
// All remaining cases could not be nullable or were trivially nullable
// Singleton cannot be nullable and Epsilon and FixedLengthMarker are trivially nullable
Debug.Assert(_kind == SymbolicRegexNodeKind.Not && _left is not null);
return _builder.Not(_left.ExtractNullabilityTest());
}
}
#endif
public override int GetHashCode()
{
return _hashcode;
}
private int ComputeHashCode()
{
switch (_kind)
{
case SymbolicRegexNodeKind.EndAnchor:
case SymbolicRegexNodeKind.BeginningAnchor:
case SymbolicRegexNodeKind.BOLAnchor:
case SymbolicRegexNodeKind.EOLAnchor:
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.BoundaryAnchor:
case SymbolicRegexNodeKind.NonBoundaryAnchor:
case SymbolicRegexNodeKind.EndAnchorZ:
case SymbolicRegexNodeKind.EndAnchorZReverse:
return HashCode.Combine(_kind, _info);
case SymbolicRegexNodeKind.FixedLengthMarker:
case SymbolicRegexNodeKind.CaptureStart:
case SymbolicRegexNodeKind.CaptureEnd:
return HashCode.Combine(_kind, _lower);
case SymbolicRegexNodeKind.Loop:
return HashCode.Combine(_kind, _left, _lower, _upper, _info);
case SymbolicRegexNodeKind.Or or SymbolicRegexNodeKind.And:
return HashCode.Combine(_kind, _alts, _info);
case SymbolicRegexNodeKind.Concat:
case SymbolicRegexNodeKind.OrderedOr:
return HashCode.Combine(_left, _right, _info);
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
return HashCode.Combine(_left, _info);
case SymbolicRegexNodeKind.Singleton:
return HashCode.Combine(_kind, _set);
default:
Debug.Assert(_kind == SymbolicRegexNodeKind.Not);
return HashCode.Combine(_kind, _left, _info);
};
}
public override bool Equals([NotNullWhen(true)] object? obj)
{
if (obj is not SymbolicRegexNode<S> that)
{
return false;
}
if (this == that)
{
return true;
}
if (_kind != that._kind)
{
return false;
}
if (_kind == SymbolicRegexNodeKind.Or)
{
if (_isInternalizedUnion && that._isInternalizedUnion)
{
// Internalized nodes that are not identical are not equal
return false;
}
// Check equality of the sets of regexes
Debug.Assert(_alts is not null && that._alts is not null);
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(_alts.Equals, that._alts);
}
return _alts.Equals(that._alts);
}
return false;
}
private void ToStringForLoop(StringBuilder sb)
{
if (_kind == SymbolicRegexNodeKind.Singleton)
{
ToString(sb);
}
else
{
sb.Append('(');
ToString(sb);
sb.Append(')');
}
}
public override string ToString()
{
StringBuilder sb = new();
ToString(sb);
return sb.ToString();
}
internal void ToString(StringBuilder sb)
{
// Guard against stack overflow due to deep recursion
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
StackHelper.CallOnEmptyStack(ToString, sb);
return;
}
switch (_kind)
{
case SymbolicRegexNodeKind.EndAnchor:
sb.Append("\\z");
return;
case SymbolicRegexNodeKind.BeginningAnchor:
sb.Append("\\A");
return;
case SymbolicRegexNodeKind.BOLAnchor:
sb.Append('^');
return;
case SymbolicRegexNodeKind.EOLAnchor:
sb.Append('$');
return;
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.FixedLengthMarker:
return;
case SymbolicRegexNodeKind.BoundaryAnchor:
sb.Append("\\b");
return;
case SymbolicRegexNodeKind.NonBoundaryAnchor:
sb.Append("\\B");
return;
case SymbolicRegexNodeKind.EndAnchorZ:
sb.Append("\\Z");
return;
case SymbolicRegexNodeKind.EndAnchorZReverse:
sb.Append("\\a");
return;
case SymbolicRegexNodeKind.Or:
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
_alts.ToString(sb);
return;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
sb.Append('(');
_left.ToString(sb);
sb.Append('|');
_right.ToString(sb);
sb.Append(')');
return;
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
_left.ToString(sb);
_right.ToString(sb);
return;
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(_set is not null);
sb.Append(_builder._solver.PrettyPrint(_set));
return;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
if (IsAnyStar)
{
sb.Append(".*");
}
else if (_lower == 0 && _upper == 1)
{
_left.ToStringForLoop(sb);
sb.Append('?');
}
else if (IsStar)
{
_left.ToStringForLoop(sb);
sb.Append('*');
if (IsLazy)
{
sb.Append('?');
}
}
else if (IsPlus)
{
_left.ToStringForLoop(sb);
sb.Append('+');
if (IsLazy)
{
sb.Append('?');
}
}
else if (_lower == 0 && _upper == 0)
{
sb.Append("()");
}
else
{
_left.ToStringForLoop(sb);
sb.Append('{');
sb.Append(_lower);
if (!IsBoundedLoop)
{
sb.Append(',');
}
else if (_lower != _upper)
{
sb.Append(',');
sb.Append(_upper);
}
sb.Append('}');
if (IsLazy)
sb.Append('?');
}
return;
case SymbolicRegexNodeKind.CaptureStart:
sb.Append('\u230A'); // Left floor
// Include group number as a subscript
Debug.Assert(_lower >= 0);
foreach (char c in _lower.ToString())
{
sb.Append((char)('\u2080' + (c - '0')));
}
return;
case SymbolicRegexNodeKind.CaptureEnd:
// Include group number as a superscript
Debug.Assert(_lower >= 0);
foreach (char c in _lower.ToString())
{
switch (c)
{
case '1':
sb.Append('\u00B9');
break;
case '2':
sb.Append('\u00B2');
break;
case '3':
sb.Append('\u00B3');
break;
default:
sb.Append((char)('\u2070' + (c - '0')));
break;
}
}
sb.Append('\u2309'); // Right ceiling
return;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
_left.ToString(sb);
return;
default:
// Using the operator ~ for complement
Debug.Assert(_kind == SymbolicRegexNodeKind.Not);
Debug.Assert(_left is not null);
sb.Append("~(");
_left.ToString(sb);
sb.Append(')');
return;
}
}
/// <summary>
/// Returns the set of all predicates that occur in the regex or
/// the set containing True if there are no precidates in the regex, e.g., if the regex is "^"
/// </summary>
public HashSet<S> GetPredicates()
{
var predicates = new HashSet<S>();
CollectPredicates_helper(predicates);
return predicates;
}
/// <summary>
/// Collects all predicates that occur in the regex into the given set predicates
/// </summary>
private void CollectPredicates_helper(HashSet<S> predicates)
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
StackHelper.CallOnEmptyStack(CollectPredicates_helper, predicates);
return;
}
switch (_kind)
{
case SymbolicRegexNodeKind.BOLAnchor:
case SymbolicRegexNodeKind.EOLAnchor:
case SymbolicRegexNodeKind.EndAnchorZ:
case SymbolicRegexNodeKind.EndAnchorZReverse:
predicates.Add(_builder._newLinePredicate);
return;
case SymbolicRegexNodeKind.BeginningAnchor:
case SymbolicRegexNodeKind.EndAnchor:
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.FixedLengthMarker:
case SymbolicRegexNodeKind.CaptureStart:
case SymbolicRegexNodeKind.CaptureEnd:
return;
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(_set is not null);
predicates.Add(_set);
return;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
_left.CollectPredicates_helper(predicates);
return;
case SymbolicRegexNodeKind.Or:
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
foreach (SymbolicRegexNode<S> sr in _alts)
{
sr.CollectPredicates_helper(predicates);
}
return;
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
_left.CollectPredicates_helper(predicates);
_right.CollectPredicates_helper(predicates);
return;
case SymbolicRegexNodeKind.Concat:
// avoid deep nested recursion over long concat nodes
SymbolicRegexNode<S> conc = this;
while (conc._kind == SymbolicRegexNodeKind.Concat)
{
Debug.Assert(conc._left is not null && conc._right is not null);
conc._left.CollectPredicates_helper(predicates);
conc = conc._right;
}
conc.CollectPredicates_helper(predicates);
return;
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
_left.CollectPredicates_helper(predicates);
return;
case SymbolicRegexNodeKind.Not:
Debug.Assert(_left is not null);
_left.CollectPredicates_helper(predicates);
return;
case SymbolicRegexNodeKind.NonBoundaryAnchor:
case SymbolicRegexNodeKind.BoundaryAnchor:
predicates.Add(_builder._wordLetterPredicateForAnchors);
return;
default:
Debug.Fail($"{nameof(CollectPredicates_helper)}:{_kind}");
break;
}
}
/// <summary>
/// Compute all the minterms from the predicates in this regex.
/// If S implements IComparable then sort the result in increasing order.
/// </summary>
public S[] ComputeMinterms()
{
Debug.Assert(typeof(S).IsAssignableTo(typeof(IComparable<S>)));
HashSet<S> predicates = GetPredicates();
List<S> mt = _builder._solver.GenerateMinterms(predicates);
mt.Sort();
return mt.ToArray();
}
/// <summary>
/// Create the reverse of this regex
/// </summary>
public SymbolicRegexNode<S> Reverse()
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(Reverse);
}
switch (_kind)
{
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
return _builder.CreateLoop(_left.Reverse(), IsLazy, _lower, _upper);
case SymbolicRegexNodeKind.Concat:
{
Debug.Assert(_left is not null && _right is not null);
SymbolicRegexNode<S> rev = _left.Reverse();
SymbolicRegexNode<S> rest = _right;
while (rest._kind == SymbolicRegexNodeKind.Concat)
{
Debug.Assert(rest._left is not null && rest._right is not null);
SymbolicRegexNode<S> rev1 = rest._left.Reverse();
rev = _builder.CreateConcat(rev1, rev);
rest = rest._right;
}
SymbolicRegexNode<S> restr = rest.Reverse();
rev = _builder.CreateConcat(restr, rev);
return rev;
}
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
return _builder.Or(_alts.Reverse());
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
return _builder.OrderedOr(_left.Reverse(), _right.Reverse());
case SymbolicRegexNodeKind.And:
Debug.Assert(_alts is not null);
return _builder.And(_alts.Reverse());
case SymbolicRegexNodeKind.Not:
Debug.Assert(_left is not null);
return _builder.Not(_left.Reverse());
case SymbolicRegexNodeKind.FixedLengthMarker:
// Fixed length markers are omitted in reverse
return _builder.Epsilon;
case SymbolicRegexNodeKind.BeginningAnchor:
// The reverse of BeginningAnchor is EndAnchor
return _builder.EndAnchor;
case SymbolicRegexNodeKind.EndAnchor:
return _builder.BeginningAnchor;
case SymbolicRegexNodeKind.BOLAnchor:
// The reverse of BOLanchor is EOLanchor
return _builder.EolAnchor;
case SymbolicRegexNodeKind.EOLAnchor:
return _builder.BolAnchor;
case SymbolicRegexNodeKind.EndAnchorZ:
// The reversal of the \Z anchor
return _builder.EndAnchorZReverse;
case SymbolicRegexNodeKind.EndAnchorZReverse:
// This can potentially only happen if a reversed regex is reversed again.
// Thus, this case is unreachable here, but included for completeness.
return _builder.EndAnchorZ;
case SymbolicRegexNodeKind.CaptureStart:
return CreateCaptureEnd(_builder, _lower);
case SymbolicRegexNodeKind.CaptureEnd:
return CreateCaptureStart(_builder, _lower);
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
return _builder.CreateDisableBacktrackingSimulation(_left.Reverse());
// Remaining cases map to themselves:
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.Singleton:
case SymbolicRegexNodeKind.BoundaryAnchor:
case SymbolicRegexNodeKind.NonBoundaryAnchor:
default:
return this;
}
}
internal bool StartsWithLoop(int upperBoundLowestValue = 1)
{
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(StartsWithLoop, upperBoundLowestValue);
}
switch (_kind)
{
case SymbolicRegexNodeKind.Loop:
return (_upper < int.MaxValue) && (_upper > upperBoundLowestValue);
case SymbolicRegexNodeKind.Concat:
Debug.Assert(_left is not null && _right is not null);
return _left.StartsWithLoop(upperBoundLowestValue) || (_left.IsNullable && _right.StartsWithLoop(upperBoundLowestValue));
case SymbolicRegexNodeKind.Or:
Debug.Assert(_alts is not null);
return _alts.StartsWithLoop(upperBoundLowestValue);
case SymbolicRegexNodeKind.OrderedOr:
Debug.Assert(_left is not null && _right is not null);
return _left.StartsWithLoop(upperBoundLowestValue) || _right.StartsWithLoop(upperBoundLowestValue);
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
return _left.StartsWithLoop(upperBoundLowestValue);
default:
return false;
};
}
/// <summary>Get the predicate that covers all elements that make some progress.</summary>
internal S GetStartSet() => _startSet;
/// <summary>Compute the predicate that covers all elements that make some progress.</summary>
private S ComputeStartSet()
{
switch (_kind)
{
// Anchors and () do not contribute to the startset
case SymbolicRegexNodeKind.Epsilon:
case SymbolicRegexNodeKind.FixedLengthMarker:
case SymbolicRegexNodeKind.EndAnchor:
case SymbolicRegexNodeKind.BeginningAnchor:
case SymbolicRegexNodeKind.BoundaryAnchor:
case SymbolicRegexNodeKind.NonBoundaryAnchor:
case SymbolicRegexNodeKind.EOLAnchor:
case SymbolicRegexNodeKind.EndAnchorZ:
case SymbolicRegexNodeKind.EndAnchorZReverse:
case SymbolicRegexNodeKind.BOLAnchor:
case SymbolicRegexNodeKind.CaptureStart:
case SymbolicRegexNodeKind.CaptureEnd:
return _builder._solver.False;
case SymbolicRegexNodeKind.Singleton:
Debug.Assert(_set is not null);
return _set;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
return _left._startSet;
case SymbolicRegexNodeKind.Concat:
{
Debug.Assert(_left is not null && _right is not null);
S startSet = _left.CanBeNullable ? _builder._solver.Or(_left._startSet, _right._startSet) : _left._startSet;
return startSet;
}
case SymbolicRegexNodeKind.Or:
{
Debug.Assert(_alts is not null);
S startSet = _builder._solver.False;
foreach (SymbolicRegexNode<S> alt in _alts)
{
startSet = _builder._solver.Or(startSet, alt._startSet);
}
return startSet;
}
case SymbolicRegexNodeKind.OrderedOr:
{
Debug.Assert(_left is not null && _right is not null);
return _builder._solver.Or(_left._startSet, _right._startSet);
}
case SymbolicRegexNodeKind.And:
{
Debug.Assert(_alts is not null);
S startSet = _builder._solver.True;
foreach (SymbolicRegexNode<S> alt in _alts)
{
startSet = _builder._solver.And(startSet, alt._startSet);
}
return startSet;
}
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
return _left._startSet;
default:
Debug.Assert(_kind == SymbolicRegexNodeKind.Not);
return _builder._solver.True;
}
}
/// <summary>
/// Returns true if this is a loop with an upper bound
/// </summary>
public bool IsBoundedLoop => _kind == SymbolicRegexNodeKind.Loop && _upper < int.MaxValue;
/// <summary>
/// Replace anchors that are infeasible by [] wrt the given previous character kind and what continuation is possible.
/// </summary>
/// <param name="prevKind">previous character kind</param>
/// <param name="contWithWL">if true the continuation can start with wordletter or stop</param>
/// <param name="contWithNWL">if true the continuation can start with nonwordletter or stop</param>
internal SymbolicRegexNode<S> PruneAnchors(uint prevKind, bool contWithWL, bool contWithNWL)
{
// Guard against stack overflow due to deep recursion
if (!StackHelper.TryEnsureSufficientExecutionStack())
{
return StackHelper.CallOnEmptyStack(PruneAnchors, prevKind, contWithWL, contWithNWL);
}
if (!_info.StartsWithSomeAnchor)
return this;
switch (_kind)
{
case SymbolicRegexNodeKind.BeginningAnchor:
return prevKind == CharKind.BeginningEnd ?
this :
_builder._nothing; //start anchor is only nullable if the previous character is Start
case SymbolicRegexNodeKind.EndAnchorZReverse:
return ((prevKind & CharKind.BeginningEnd) != 0) ?
this :
_builder._nothing; //rev(\Z) is only nullable if the previous characters is Start or the very first \n
case SymbolicRegexNodeKind.BoundaryAnchor:
return (prevKind == CharKind.WordLetter ? contWithNWL : contWithWL) ?
this :
// \b is impossible when the previous character is \w but no continuation matches \W
// or the previous character is \W but no continuation matches \w
_builder._nothing;
case SymbolicRegexNodeKind.NonBoundaryAnchor:
return (prevKind == CharKind.WordLetter ? contWithWL : contWithNWL) ?
this :
// \B is impossible when the previous character is \w but no continuation matches \w
// or the previous character is \W but no continuation matches \W
_builder._nothing;
case SymbolicRegexNodeKind.Loop:
Debug.Assert(_left is not null);
SymbolicRegexNode<S> body = _left.PruneAnchors(prevKind, contWithWL, contWithNWL);
return body == _left ?
this :
CreateLoop(_builder, body, _lower, _upper, IsLazy);
case SymbolicRegexNodeKind.Concat:
{
Debug.Assert(_left is not null && _right is not null);
SymbolicRegexNode<S> left1 = _left.PruneAnchors(prevKind, contWithWL, contWithNWL);
SymbolicRegexNode<S> right1 = _left.IsNullable ? _right.PruneAnchors(prevKind, contWithWL, contWithNWL) : _right;
Debug.Assert(left1 is not null && right1 is not null);
return left1 == _left && right1 == _right ?
this :
CreateConcat(_builder, left1, right1);
}
case SymbolicRegexNodeKind.Or:
{
Debug.Assert(_alts != null);
var elements = new SymbolicRegexNode<S>[_alts.Count];
int i = 0;
foreach (SymbolicRegexNode<S> alt in _alts)
{
elements[i++] = alt.PruneAnchors(prevKind, contWithWL, contWithNWL);
}
Debug.Assert(i == elements.Length);
return Or(_builder, elements);
}
case SymbolicRegexNodeKind.OrderedOr:
{
Debug.Assert(_left is not null && _right is not null);
SymbolicRegexNode<S> left1 = _left.PruneAnchors(prevKind, contWithWL, contWithNWL);
SymbolicRegexNode<S> right1 = _right.PruneAnchors(prevKind, contWithWL, contWithNWL);
Debug.Assert(left1 is not null && right1 is not null);
return left1 == _left && right1 == _right ?
this :
OrderedOr(_builder, left1, right1);
}
case SymbolicRegexNodeKind.DisableBacktrackingSimulation:
Debug.Assert(_left is not null);
SymbolicRegexNode<S> child = _left.PruneAnchors(prevKind, contWithWL, contWithNWL);
return child == _left ?
this :
_builder.CreateDisableBacktrackingSimulation(child);
default:
return this;
}
}
}
}
| 1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/CustomDerivedRegexScenarioTest.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading;
using Xunit;
namespace System.Text.RegularExpressions.Tests
{
public class CustomDerivedRegexScenarioTest
{
[Fact]
public void CallProtectedScanMethodFromCustomDerivedRegex()
{
CustomDerivedRegex regex = new();
Assert.True(regex.CallScanDirectly(regex, "3456", 0, 4, 0, -1, false).Success);
Assert.False(regex.CallScanDirectly(regex, "456", 0, 3, 0, -1, false).Success);
Assert.Equal("45", regex.CallScanDirectly(regex, "45456", 0, 5, 0, -1, false).Value);
Assert.Equal("896", regex.CallScanDirectly(regex, "45896456", 0, 8, 2, -1, false).Value);
Assert.Equal(Match.Empty, regex.CallScanDirectly(regex, "I dont match", 0, 12, 0, -1, false));
Assert.Null(regex.CallScanDirectly(regex, "3456", 0, 4, 0, -1, true));
}
}
/// <summary>
/// This type was generated using an earlier version of the Regex Source Generator which still overrides Go and FindFirstChar.
/// The purpose of this class is to validate that if a derived RegexRunner is invoking the protected Scan methods, they should call
/// the overridden Go and FindFirstChar methods and return the expected results.
/// </summary>
internal class CustomDerivedRegex : Regex
{
private CustomRegexRunnerFactory.CustomRegexRunner runner;
public CustomDerivedRegex()
{
pattern = /*lang=regex*/@"\G(\d{1,3})(?=(?:\d{3})+\b)";
roptions = RegexOptions.Compiled;
internalMatchTimeout = Timeout.InfiniteTimeSpan;
factory = new CustomRegexRunnerFactory();
capsize = 2;
MethodInfo createRunnerMethod = typeof(Regex).GetMethod("CreateRunner", BindingFlags.Instance | BindingFlags.NonPublic);
runner = createRunnerMethod.Invoke(this, new object[] { }) as CustomRegexRunnerFactory.CustomRegexRunner;
}
public Match? CallScanDirectly(Regex regex, string text, int textbeg, int textend, int textstart, int prevlen, bool quick)
=> runner.CallScanDirectly(regex, text, textbeg, textend, textstart, prevlen, quick);
internal class CustomRegexRunnerFactory : RegexRunnerFactory
{
protected override RegexRunner CreateInstance() => new CustomRegexRunner();
internal class CustomRegexRunner : RegexRunner
{
public Match? CallScanDirectly(Regex regex, string text, int textbeg, int textend, int textstart, int prevlen, bool quick)
=> Scan(regex, text, textbeg, textend, textstart, prevlen, quick);
protected override void InitTrackCount() => base.runtrackcount = 12;
// Description:
// ○ Match if at the start position.
// ○ 1st capture group.
// ○ Match a Unicode digit greedily at least 1 and at most 3 times.
// ○ Zero-width positive lookahead assertion.
// ○ Loop greedily at least once.
// ○ Match a Unicode digit exactly 3 times.
// ○ Match if at a word boundary.
protected override bool FindFirstChar()
{
int pos = runtextpos, end = runtextend;
if (pos < end)
{
// Start \G anchor
if (pos > runtextstart)
{
goto NoStartingPositionFound;
}
return true;
}
// No starting position found
NoStartingPositionFound:
runtextpos = end;
return false;
}
protected override void Go()
{
ReadOnlySpan<char> inputSpan = runtext.AsSpan();
int pos = base.runtextpos, end = base.runtextend;
int original_pos = pos;
int charloop_starting_pos = 0, charloop_ending_pos = 0;
int loop_iteration = 0, loop_starting_pos = 0;
int stackpos = 0;
int start = base.runtextstart;
ReadOnlySpan<char> slice = inputSpan.Slice(pos, end - pos);
// Match if at the start position.
{
if (pos != start)
{
goto NoMatch;
}
}
// 1st capture group.
//{
int capture_starting_pos = pos;
// Match a Unicode digit greedily at least 1 and at most 3 times.
//{
charloop_starting_pos = pos;
int iteration = 0;
while (iteration < 3 && (uint)iteration < (uint)slice.Length && char.IsDigit(slice[iteration]))
{
iteration++;
}
if (iteration == 0)
{
goto NoMatch;
}
slice = slice.Slice(iteration);
pos += iteration;
charloop_ending_pos = pos;
charloop_starting_pos++;
goto CharLoopEnd;
CharLoopBacktrack:
UncaptureUntil(base.runstack![--stackpos]);
StackPop2(base.runstack, ref stackpos, out charloop_ending_pos, out charloop_starting_pos);
if (charloop_starting_pos >= charloop_ending_pos)
{
goto NoMatch;
}
pos = --charloop_ending_pos;
slice = inputSpan.Slice(pos, end - pos);
CharLoopEnd:
StackPush3(ref base.runstack!, ref stackpos, charloop_starting_pos, charloop_ending_pos, base.Crawlpos());
//}
base.Capture(1, capture_starting_pos, pos);
StackPush1(ref base.runstack!, ref stackpos, capture_starting_pos);
goto SkipBacktrack;
CaptureBacktrack:
capture_starting_pos = base.runstack![--stackpos];
goto CharLoopBacktrack;
SkipBacktrack:;
//}
// Zero-width positive lookahead assertion.
{
int positivelookahead_starting_pos = pos;
// Loop greedily at least once.
//{
loop_iteration = 0;
loop_starting_pos = pos;
LoopBody:
StackPush3(ref base.runstack!, ref stackpos, base.Crawlpos(), loop_starting_pos, pos);
loop_starting_pos = pos;
loop_iteration++;
// Match a Unicode digit exactly 3 times.
{
if ((uint)slice.Length < 3 ||
!char.IsDigit(slice[0]) ||
!char.IsDigit(slice[1]) ||
!char.IsDigit(slice[2]))
{
goto LoopIterationNoMatch;
}
}
pos += 3;
slice = slice.Slice(3);
if (pos != loop_starting_pos || loop_iteration == 0)
{
goto LoopBody;
}
goto LoopEnd;
LoopIterationNoMatch:
loop_iteration--;
if (loop_iteration < 0)
{
goto CaptureBacktrack;
}
StackPop2(base.runstack, ref stackpos, out pos, out loop_starting_pos);
UncaptureUntil(base.runstack![--stackpos]);
slice = inputSpan.Slice(pos, end - pos);
if (loop_iteration == 0)
{
goto CaptureBacktrack;
}
if (loop_iteration == 0)
{
goto CaptureBacktrack;
}
LoopEnd:;
//}
// Match if at a word boundary.
{
if (!base.IsBoundary(pos, base.runtextbeg, end))
{
goto LoopIterationNoMatch;
}
}
pos = positivelookahead_starting_pos;
slice = inputSpan.Slice(pos, end - pos);
}
// The input matched.
base.runtextpos = pos;
base.Capture(0, original_pos, pos);
return;
// The input didn't match.
NoMatch:
UncaptureUntil(0);
return;
// <summary>Pop 2 values from the backtracking stack.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static void StackPop2(int[] stack, ref int pos, out int arg0, out int arg1)
{
arg0 = stack[--pos];
arg1 = stack[--pos];
}
// <summary>Push 1 value onto the backtracking stack.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static void StackPush1(ref int[] stack, ref int pos, int arg0)
{
// If there's space available for the value, store it.
int[] s = stack;
int p = pos;
if ((uint)p < (uint)s.Length)
{
s[p] = arg0;
pos++;
return;
}
// Otherwise, resize the stack to make room and try again.
WithResize(ref stack, ref pos, arg0);
// <summary>Resize the backtracking stack array and push 1 value onto the stack.</summary>
[MethodImpl(MethodImplOptions.NoInlining)]
static void WithResize(ref int[] stack, ref int pos, int arg0)
{
Array.Resize(ref stack, (pos + 0) * 2);
StackPush1(ref stack, ref pos, arg0);
}
}
// <summary>Push 3 values onto the backtracking stack.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static void StackPush3(ref int[] stack, ref int pos, int arg0, int arg1, int arg2)
{
// If there's space available for all 3 values, store them.
int[] s = stack;
int p = pos;
if ((uint)(p + 2) < (uint)s.Length)
{
s[p] = arg0;
s[p + 1] = arg1;
s[p + 2] = arg2;
pos += 3;
return;
}
// Otherwise, resize the stack to make room and try again.
WithResize(ref stack, ref pos, arg0, arg1, arg2);
// <summary>Resize the backtracking stack array and push 3 values onto the stack.</summary>
[MethodImpl(MethodImplOptions.NoInlining)]
static void WithResize(ref int[] stack, ref int pos, int arg0, int arg1, int arg2)
{
Array.Resize(ref stack, (pos + 2) * 2);
StackPush3(ref stack, ref pos, arg0, arg1, arg2);
}
}
// <summary>Undo captures until we reach the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturepos)
{
while (base.Crawlpos() > capturepos)
{
base.Uncapture();
}
}
}
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading;
using Xunit;
namespace System.Text.RegularExpressions.Tests
{
public class CustomDerivedRegexScenarioTest
{
[Fact]
public void CallProtectedScanMethodFromCustomDerivedRegex()
{
CustomDerivedRegex regex = new();
Assert.True(regex.CallScanDirectly(regex, "3456", 0, 4, 0, -1, false).Success);
Assert.False(regex.CallScanDirectly(regex, "456", 0, 3, 0, -1, false).Success);
Assert.Equal("45", regex.CallScanDirectly(regex, "45456", 0, 5, 0, -1, false).Value);
Assert.Equal("896", regex.CallScanDirectly(regex, "45896456", 0, 8, 2, -1, false).Value);
Assert.Equal(Match.Empty, regex.CallScanDirectly(regex, "I dont match", 0, 12, 0, -1, false));
Assert.Null(regex.CallScanDirectly(regex, "3456", 0, 4, 0, -1, true));
}
}
/// <summary>
/// This type was generated using an earlier version of the Regex Source Generator which still overrides Go and FindFirstChar.
/// The purpose of this class is to validate that if a derived RegexRunner is invoking the protected Scan methods, they should call
/// the overridden Go and FindFirstChar methods and return the expected results.
/// </summary>
internal class CustomDerivedRegex : Regex
{
private CustomRegexRunnerFactory.CustomRegexRunner runner;
public CustomDerivedRegex()
{
pattern = @"\G(\d{1,3})(?=(?:\d{3})+\b)";
roptions = RegexOptions.Compiled;
internalMatchTimeout = Timeout.InfiniteTimeSpan;
factory = new CustomRegexRunnerFactory();
capsize = 2;
MethodInfo createRunnerMethod = typeof(Regex).GetMethod("CreateRunner", BindingFlags.Instance | BindingFlags.NonPublic);
runner = createRunnerMethod.Invoke(this, new object[] { }) as CustomRegexRunnerFactory.CustomRegexRunner;
}
public Match? CallScanDirectly(Regex regex, string text, int textbeg, int textend, int textstart, int prevlen, bool quick)
=> runner.CallScanDirectly(regex, text, textbeg, textend, textstart, prevlen, quick);
internal class CustomRegexRunnerFactory : RegexRunnerFactory
{
protected override RegexRunner CreateInstance() => new CustomRegexRunner();
internal class CustomRegexRunner : RegexRunner
{
public Match? CallScanDirectly(Regex regex, string text, int textbeg, int textend, int textstart, int prevlen, bool quick)
=> Scan(regex, text, textbeg, textend, textstart, prevlen, quick);
protected override void InitTrackCount() => base.runtrackcount = 12;
// Description:
// ○ Match if at the start position.
// ○ 1st capture group.
// ○ Match a Unicode digit greedily at least 1 and at most 3 times.
// ○ Zero-width positive lookahead assertion.
// ○ Loop greedily at least once.
// ○ Match a Unicode digit exactly 3 times.
// ○ Match if at a word boundary.
protected override bool FindFirstChar()
{
int pos = runtextpos, end = runtextend;
if (pos < end)
{
// Start \G anchor
if (pos > runtextstart)
{
goto NoStartingPositionFound;
}
return true;
}
// No starting position found
NoStartingPositionFound:
runtextpos = end;
return false;
}
protected override void Go()
{
ReadOnlySpan<char> inputSpan = runtext.AsSpan();
int pos = base.runtextpos, end = base.runtextend;
int original_pos = pos;
int charloop_starting_pos = 0, charloop_ending_pos = 0;
int loop_iteration = 0, loop_starting_pos = 0;
int stackpos = 0;
int start = base.runtextstart;
ReadOnlySpan<char> slice = inputSpan.Slice(pos, end - pos);
// Match if at the start position.
{
if (pos != start)
{
goto NoMatch;
}
}
// 1st capture group.
//{
int capture_starting_pos = pos;
// Match a Unicode digit greedily at least 1 and at most 3 times.
//{
charloop_starting_pos = pos;
int iteration = 0;
while (iteration < 3 && (uint)iteration < (uint)slice.Length && char.IsDigit(slice[iteration]))
{
iteration++;
}
if (iteration == 0)
{
goto NoMatch;
}
slice = slice.Slice(iteration);
pos += iteration;
charloop_ending_pos = pos;
charloop_starting_pos++;
goto CharLoopEnd;
CharLoopBacktrack:
UncaptureUntil(base.runstack![--stackpos]);
StackPop2(base.runstack, ref stackpos, out charloop_ending_pos, out charloop_starting_pos);
if (charloop_starting_pos >= charloop_ending_pos)
{
goto NoMatch;
}
pos = --charloop_ending_pos;
slice = inputSpan.Slice(pos, end - pos);
CharLoopEnd:
StackPush3(ref base.runstack!, ref stackpos, charloop_starting_pos, charloop_ending_pos, base.Crawlpos());
//}
base.Capture(1, capture_starting_pos, pos);
StackPush1(ref base.runstack!, ref stackpos, capture_starting_pos);
goto SkipBacktrack;
CaptureBacktrack:
capture_starting_pos = base.runstack![--stackpos];
goto CharLoopBacktrack;
SkipBacktrack:;
//}
// Zero-width positive lookahead assertion.
{
int positivelookahead_starting_pos = pos;
// Loop greedily at least once.
//{
loop_iteration = 0;
loop_starting_pos = pos;
LoopBody:
StackPush3(ref base.runstack!, ref stackpos, base.Crawlpos(), loop_starting_pos, pos);
loop_starting_pos = pos;
loop_iteration++;
// Match a Unicode digit exactly 3 times.
{
if ((uint)slice.Length < 3 ||
!char.IsDigit(slice[0]) ||
!char.IsDigit(slice[1]) ||
!char.IsDigit(slice[2]))
{
goto LoopIterationNoMatch;
}
}
pos += 3;
slice = slice.Slice(3);
if (pos != loop_starting_pos || loop_iteration == 0)
{
goto LoopBody;
}
goto LoopEnd;
LoopIterationNoMatch:
loop_iteration--;
if (loop_iteration < 0)
{
goto CaptureBacktrack;
}
StackPop2(base.runstack, ref stackpos, out pos, out loop_starting_pos);
UncaptureUntil(base.runstack![--stackpos]);
slice = inputSpan.Slice(pos, end - pos);
if (loop_iteration == 0)
{
goto CaptureBacktrack;
}
if (loop_iteration == 0)
{
goto CaptureBacktrack;
}
LoopEnd:;
//}
// Match if at a word boundary.
{
if (!base.IsBoundary(pos, base.runtextbeg, end))
{
goto LoopIterationNoMatch;
}
}
pos = positivelookahead_starting_pos;
slice = inputSpan.Slice(pos, end - pos);
}
// The input matched.
base.runtextpos = pos;
base.Capture(0, original_pos, pos);
return;
// The input didn't match.
NoMatch:
UncaptureUntil(0);
return;
// <summary>Pop 2 values from the backtracking stack.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static void StackPop2(int[] stack, ref int pos, out int arg0, out int arg1)
{
arg0 = stack[--pos];
arg1 = stack[--pos];
}
// <summary>Push 1 value onto the backtracking stack.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static void StackPush1(ref int[] stack, ref int pos, int arg0)
{
// If there's space available for the value, store it.
int[] s = stack;
int p = pos;
if ((uint)p < (uint)s.Length)
{
s[p] = arg0;
pos++;
return;
}
// Otherwise, resize the stack to make room and try again.
WithResize(ref stack, ref pos, arg0);
// <summary>Resize the backtracking stack array and push 1 value onto the stack.</summary>
[MethodImpl(MethodImplOptions.NoInlining)]
static void WithResize(ref int[] stack, ref int pos, int arg0)
{
Array.Resize(ref stack, (pos + 0) * 2);
StackPush1(ref stack, ref pos, arg0);
}
}
// <summary>Push 3 values onto the backtracking stack.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static void StackPush3(ref int[] stack, ref int pos, int arg0, int arg1, int arg2)
{
// If there's space available for all 3 values, store them.
int[] s = stack;
int p = pos;
if ((uint)(p + 2) < (uint)s.Length)
{
s[p] = arg0;
s[p + 1] = arg1;
s[p + 2] = arg2;
pos += 3;
return;
}
// Otherwise, resize the stack to make room and try again.
WithResize(ref stack, ref pos, arg0, arg1, arg2);
// <summary>Resize the backtracking stack array and push 3 values onto the stack.</summary>
[MethodImpl(MethodImplOptions.NoInlining)]
static void WithResize(ref int[] stack, ref int pos, int arg0, int arg1, int arg2)
{
Array.Resize(ref stack, (pos + 2) * 2);
StackPush3(ref stack, ref pos, arg0, arg1, arg2);
}
}
// <summary>Undo captures until we reach the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturepos)
{
while (base.Crawlpos() > capturepos)
{
base.Uncapture();
}
}
}
}
}
}
}
| 1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/Regex.Tests.Common.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Xunit;
namespace System.Text.RegularExpressions.Tests
{
public static class RegexHelpers
{
public const string DefaultMatchTimeout_ConfigKeyName = "REGEX_DEFAULT_MATCH_TIMEOUT";
public const int StressTestNestingDepth = 1000;
/// <summary>RegexOptions.NonBacktracking.</summary>
/// <remarks>Defined here to be able to reference the value by name even on .NET Framework test builds.</remarks>
public const RegexOptions RegexOptionNonBacktracking = (RegexOptions)0x400;
/// <summary>RegexOptions.NonBacktracking.</summary>
/// <remarks>Defined here to be able to reference the value even in release builds.</remarks>
public const RegexOptions RegexOptionDebug = (RegexOptions)0x80;
static RegexHelpers()
{
if (PlatformDetection.IsNetCore)
{
Assert.Equal(RegexOptionNonBacktracking, Enum.Parse(typeof(RegexOptions), "NonBacktracking"));
}
}
public static bool IsDefaultCount(string input, RegexOptions options, int count)
{
if ((options & RegexOptions.RightToLeft) != 0)
{
return count == input.Length || count == -1;
}
return count == input.Length;
}
public static bool IsDefaultStart(string input, RegexOptions options, int start)
{
if ((options & RegexOptions.RightToLeft) != 0)
{
return start == input.Length;
}
return start == 0;
}
public static async Task<Regex> GetRegexAsync(RegexEngine engine, string pattern, RegexOptions options, Globalization.CultureInfo culture)
{
using (new System.Tests.ThreadCultureChange(culture))
{
return await GetRegexAsync(engine, pattern, options);
}
}
public static IEnumerable<object[]> AvailableEngines_MemberData =>
from engine in AvailableEngines
select new object[] { engine };
public static IEnumerable<object[]> PrependEngines(IEnumerable<object[]> cases)
{
foreach (RegexEngine engine in AvailableEngines)
{
foreach (object[] additionalParameters in cases)
{
var parameters = new object[additionalParameters.Length + 1];
additionalParameters.CopyTo(parameters, 1);
parameters[0] = engine;
yield return parameters;
}
}
}
public static IEnumerable<RegexEngine> AvailableEngines
{
get
{
yield return RegexEngine.Interpreter;
yield return RegexEngine.Compiled;
if (PlatformDetection.IsNetCore)
{
yield return RegexEngine.NonBacktracking;
if (PlatformDetection.IsReflectionEmitSupported && // the source generator doesn't use reflection emit, but it does use Roslyn for the equivalent
PlatformDetection.IsNotMobile &&
PlatformDetection.IsNotBrowser)
{
yield return RegexEngine.SourceGenerated;
// TODO-NONBACKTRACKING:
// yield return RegexEngine.NonBacktrackingSourceGenerated;
}
}
}
}
public static bool IsNonBacktracking(RegexEngine engine) =>
engine is RegexEngine.NonBacktracking or RegexEngine.NonBacktrackingSourceGenerated;
public static async Task<Regex> GetRegexAsync(RegexEngine engine, string pattern, RegexOptions? options = null, TimeSpan? matchTimeout = null)
{
if (options is null)
{
Assert.Null(matchTimeout);
}
if (engine == RegexEngine.SourceGenerated)
{
return await RegexGeneratorHelper.SourceGenRegexAsync(pattern, options, matchTimeout);
}
// TODO-NONBACKTRACKING
// - Handle NonBacktrackingSourceGenerated
return
options is null ? new Regex(pattern, OptionsFromEngine(engine)) :
matchTimeout is null ? new Regex(pattern, options.Value | OptionsFromEngine(engine)) :
new Regex(pattern, options.Value | OptionsFromEngine(engine), matchTimeout.Value);
}
public static async Task<Regex[]> GetRegexesAsync(RegexEngine engine, params (string pattern, RegexOptions? options, TimeSpan? matchTimeout)[] regexes)
{
if (engine == RegexEngine.SourceGenerated)
{
return await RegexGeneratorHelper.SourceGenRegexAsync(regexes);
}
// TODO-NONBACKTRACKING
// - Handle NonBacktrackingSourceGenerated
var results = new Regex[regexes.Length];
for (int i = 0; i < regexes.Length; i++)
{
(string pattern, RegexOptions? options, TimeSpan? matchTimeout) = regexes[i];
results[i] =
options is null ? new Regex(pattern, OptionsFromEngine(engine)) :
matchTimeout is null ? new Regex(pattern, options.Value | OptionsFromEngine(engine)) :
new Regex(pattern, options.Value | OptionsFromEngine(engine), matchTimeout.Value);
}
return results;
}
public static RegexOptions OptionsFromEngine(RegexEngine engine) => engine switch
{
RegexEngine.Interpreter => RegexOptions.None,
RegexEngine.Compiled => RegexOptions.Compiled,
RegexEngine.SourceGenerated => RegexOptions.Compiled,
RegexEngine.NonBacktracking => RegexOptionNonBacktracking,
RegexEngine.NonBacktrackingSourceGenerated => RegexOptionNonBacktracking | RegexOptions.Compiled,
_ => throw new ArgumentException($"Unknown engine: {engine}"),
};
}
public enum RegexEngine
{
Interpreter,
Compiled,
NonBacktracking,
SourceGenerated,
NonBacktrackingSourceGenerated,
}
public class CaptureData
{
private CaptureData(string value, int index, int length, bool createCaptures)
{
Value = value;
Index = index;
Length = length;
// Prevent a StackOverflow recursion in the constructor
if (createCaptures)
{
Captures = new CaptureData[] { new CaptureData(value, index, length, false) };
}
}
public CaptureData(string value, int index, int length) : this(value, index, length, true)
{
}
public CaptureData(string value, int index, int length, CaptureData[] captures) : this(value, index, length, false)
{
Captures = captures;
}
public string Value { get; }
public int Index { get; }
public int Length { get; }
public CaptureData[] Captures { get; }
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading.Tasks;
using Xunit;
namespace System.Text.RegularExpressions.Tests
{
public static class RegexHelpers
{
public const string DefaultMatchTimeout_ConfigKeyName = "REGEX_DEFAULT_MATCH_TIMEOUT";
public const int StressTestNestingDepth = 1000;
/// <summary>RegexOptions.NonBacktracking.</summary>
/// <remarks>Defined here to be able to reference the value by name even on .NET Framework test builds.</remarks>
public const RegexOptions RegexOptionNonBacktracking = (RegexOptions)0x400;
/// <summary>RegexOptions.NonBacktracking.</summary>
/// <remarks>Defined here to be able to reference the value even in release builds.</remarks>
public const RegexOptions RegexOptionDebug = (RegexOptions)0x80;
static RegexHelpers()
{
if (PlatformDetection.IsNetCore)
{
Assert.Equal(RegexOptionNonBacktracking, Enum.Parse(typeof(RegexOptions), "NonBacktracking"));
}
}
public static bool IsDefaultCount(string input, RegexOptions options, int count)
{
if ((options & RegexOptions.RightToLeft) != 0)
{
return count == input.Length || count == -1;
}
return count == input.Length;
}
public static bool IsDefaultStart(string input, RegexOptions options, int start)
{
if ((options & RegexOptions.RightToLeft) != 0)
{
return start == input.Length;
}
return start == 0;
}
public static async Task<Regex> GetRegexAsync(RegexEngine engine, [StringSyntax(StringSyntaxAttribute.Regex)] string pattern, RegexOptions options, Globalization.CultureInfo culture)
{
using (new System.Tests.ThreadCultureChange(culture))
{
return await GetRegexAsync(engine, pattern, options);
}
}
public static IEnumerable<object[]> AvailableEngines_MemberData =>
from engine in AvailableEngines
select new object[] { engine };
public static IEnumerable<object[]> PrependEngines(IEnumerable<object[]> cases)
{
foreach (RegexEngine engine in AvailableEngines)
{
foreach (object[] additionalParameters in cases)
{
var parameters = new object[additionalParameters.Length + 1];
additionalParameters.CopyTo(parameters, 1);
parameters[0] = engine;
yield return parameters;
}
}
}
public static IEnumerable<RegexEngine> AvailableEngines
{
get
{
yield return RegexEngine.Interpreter;
yield return RegexEngine.Compiled;
if (PlatformDetection.IsNetCore)
{
yield return RegexEngine.NonBacktracking;
if (PlatformDetection.IsReflectionEmitSupported && // the source generator doesn't use reflection emit, but it does use Roslyn for the equivalent
PlatformDetection.IsNotMobile &&
PlatformDetection.IsNotBrowser)
{
yield return RegexEngine.SourceGenerated;
// TODO-NONBACKTRACKING:
// yield return RegexEngine.NonBacktrackingSourceGenerated;
}
}
}
}
public static bool IsNonBacktracking(RegexEngine engine) =>
engine is RegexEngine.NonBacktracking or RegexEngine.NonBacktrackingSourceGenerated;
public static async Task<Regex> GetRegexAsync(RegexEngine engine, [StringSyntax(StringSyntaxAttribute.Regex)] string pattern, RegexOptions? options = null, TimeSpan? matchTimeout = null)
{
if (options is null)
{
Assert.Null(matchTimeout);
}
if (engine == RegexEngine.SourceGenerated)
{
return await RegexGeneratorHelper.SourceGenRegexAsync(pattern, options, matchTimeout);
}
// TODO-NONBACKTRACKING
// - Handle NonBacktrackingSourceGenerated
return
options is null ? new Regex(pattern, OptionsFromEngine(engine)) :
matchTimeout is null ? new Regex(pattern, options.Value | OptionsFromEngine(engine)) :
new Regex(pattern, options.Value | OptionsFromEngine(engine), matchTimeout.Value);
}
public static async Task<Regex[]> GetRegexesAsync(RegexEngine engine, params (string pattern, RegexOptions? options, TimeSpan? matchTimeout)[] regexes)
{
if (engine == RegexEngine.SourceGenerated)
{
return await RegexGeneratorHelper.SourceGenRegexAsync(regexes);
}
// TODO-NONBACKTRACKING
// - Handle NonBacktrackingSourceGenerated
var results = new Regex[regexes.Length];
for (int i = 0; i < regexes.Length; i++)
{
(string pattern, RegexOptions? options, TimeSpan? matchTimeout) = regexes[i];
results[i] =
options is null ? new Regex(pattern, OptionsFromEngine(engine)) :
matchTimeout is null ? new Regex(pattern, options.Value | OptionsFromEngine(engine)) :
new Regex(pattern, options.Value | OptionsFromEngine(engine), matchTimeout.Value);
}
return results;
}
public static RegexOptions OptionsFromEngine(RegexEngine engine) => engine switch
{
RegexEngine.Interpreter => RegexOptions.None,
RegexEngine.Compiled => RegexOptions.Compiled,
RegexEngine.SourceGenerated => RegexOptions.Compiled,
RegexEngine.NonBacktracking => RegexOptionNonBacktracking,
RegexEngine.NonBacktrackingSourceGenerated => RegexOptionNonBacktracking | RegexOptions.Compiled,
_ => throw new ArgumentException($"Unknown engine: {engine}"),
};
}
public enum RegexEngine
{
Interpreter,
Compiled,
NonBacktracking,
SourceGenerated,
NonBacktrackingSourceGenerated,
}
public class CaptureData
{
private CaptureData(string value, int index, int length, bool createCaptures)
{
Value = value;
Index = index;
Length = length;
// Prevent a StackOverflow recursion in the constructor
if (createCaptures)
{
Captures = new CaptureData[] { new CaptureData(value, index, length, false) };
}
}
public CaptureData(string value, int index, int length) : this(value, index, length, true)
{
}
public CaptureData(string value, int index, int length, CaptureData[] captures) : this(value, index, length, false)
{
Captures = captures;
}
public string Value { get; }
public int Index { get; }
public int Length { get; }
public CaptureData[] Captures { get; }
}
}
| 1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/RegexExperiment.cs
|
// Licensed to the .NET Foundation under one or more agreements.if #DEBUG
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using Xunit;
using Xunit.Abstractions;
using System.Threading.Tasks;
namespace System.Text.RegularExpressions.Tests
{
/// <summary>
/// This class is to be ignored wrt unit tests in Release mode.
/// It contains temporary experimental code, such as lightweight profiling and debuggging locally.
/// Set <see cref="Enabled"/> to true to run all the tests.
/// </summary>
public class RegexExperiment
{
private readonly ITestOutputHelper _output;
public RegexExperiment(ITestOutputHelper output) => _output = output;
public static bool Enabled => false;
/// <summary>Temporary local output directory for experiment results.</summary>
private static readonly string s_tmpWorkingDir = Path.GetTempPath();
/// <summary>Works as a console.</summary>
private static string OutputFilePath => Path.Combine(s_tmpWorkingDir, "vsoutput.txt");
/// <summary>Output directory for generated dgml files.</summary>
private static string DgmlOutputDirectoryPath => Path.Combine(s_tmpWorkingDir, "dgml");
[Fact]
public void RegenerateUnicodeTables()
{
if (!Enabled)
{
return;
}
MethodInfo? genUnicode = typeof(Regex).GetMethod("GenerateUnicodeTables", BindingFlags.NonPublic | BindingFlags.Static);
// GenerateUnicodeTables is not available in Release build
if (genUnicode is not null)
{
genUnicode.Invoke(null, new object[] { s_tmpWorkingDir });
}
}
/// <summary>Save the regex as a DFA in DGML format in the textwriter.</summary>
private static bool TrySaveDGML(Regex regex, TextWriter writer, int bound = -1, bool hideStateInfo = false, bool addDotStar = false, bool inReverse = false, bool onlyDFAinfo = false, int maxLabelLength = -1, bool asNFA = false)
{
MethodInfo? saveDgml = regex.GetType().GetMethod("SaveDGML", BindingFlags.NonPublic | BindingFlags.Instance);
if (saveDgml is null)
{
return false;
}
else
{
saveDgml.Invoke(regex, new object[] { writer, bound, hideStateInfo, addDotStar, inReverse, onlyDFAinfo, maxLabelLength, asNFA });
return true;
}
}
/// <summary>View the regex as a DFA in DGML format in VS.</summary>
internal static void ViewDGML(Regex regex, int bound = -1, bool hideStateInfo = true, bool addDotStar = false, bool inReverse = false, bool onlyDFAinfo = false, string name = "DFA", int maxLabelLength = 20, bool asNFA = false)
{
if (!Directory.Exists(DgmlOutputDirectoryPath))
{
Directory.CreateDirectory(DgmlOutputDirectoryPath);
}
var sw = new StringWriter();
// If TrySaveDGML returns false then Regex.SaveDGML is not supported (in Release build)
if (TrySaveDGML(regex, sw, bound, hideStateInfo, addDotStar, inReverse, onlyDFAinfo, maxLabelLength, asNFA))
{
if (asNFA)
{
name = "NFA";
}
File.WriteAllText(Path.Combine(DgmlOutputDirectoryPath, $"{(inReverse ? name + "r" : (addDotStar ? name + "1" : name))}.dgml"), sw.ToString());
}
}
private static long MeasureMatchTime(Regex re, string input, out Match match)
{
try
{
var sw = Stopwatch.StartNew();
match = re.Match(input);
return sw.ElapsedMilliseconds;
}
catch (RegexMatchTimeoutException)
{
match = Match.Empty;
return -1;
}
catch (Exception)
{
match = Match.Empty;
return -2;
}
}
/// <summary>
/// Creates a regex that in the NonBacktracking engine in DEBUG mode represents intersection of regexes
/// </summary>
private static string And(params string[] regexes)
{
string conj = $"(?:{regexes[regexes.Length - 1]})";
for (int i = regexes.Length - 2; i >= 0; i--)
{
conj = $"(?({regexes[i]}){conj}|[0-[0]])";
}
return conj;
}
/// <summary>
/// Creates a regex that in the NonBacktracking engine in DEBUG mode represents complement of regex
/// </summary>
private static string Not(string regex) => $"(?({regex})[0-[0]]|.*)";
[Fact]
public void ViewSampleRegexInDGML()
{
if (!Enabled)
{
return;
}
try
{
//string rawregex = @"\bis\w*\b";
string rawregex = And(".*[0-9].*[0-9].*", ".*[A-Z].*[A-Z].*", Not(".*(01|12).*"));
//string rawregex = "a.{4}$";
Regex re = new Regex($@"{rawregex}", RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
ViewDGML(re);
ViewDGML(re, inReverse: true);
ViewDGML(re, addDotStar: true);
ViewDGML(re, asNFA: true, bound: 12);
ViewDGML(re, inReverse: true, asNFA: true, bound: 12);
ViewDGML(re, addDotStar: true, asNFA: true, bound: 12);
}
catch (NotSupportedException e)
{
Assert.Contains("conditional", e.Message);
}
}
[ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
[InlineData(".*a+", -1, new string[] { ".*a+" }, false, false)]
[InlineData("ann", -1, new string[] { "nna" }, true, false)]
[InlineData("(something|otherstuff)+", 10, new string[] { "Unexplored", "some" }, false, true)]
[InlineData("(something|otherstuff)+", 10, new string[] { "Unexplored", "ffut" }, true, true)]
public void TestDGMLGeneration(string pattern, int explorationbound, string[] expectedDgmlFragments, bool exploreInReverse, bool exploreAsNFA)
{
StringWriter sw = new StringWriter();
var re = new Regex(pattern, RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
if (TrySaveDGML(re, writer: sw, bound: explorationbound, inReverse: exploreInReverse, asNFA: exploreAsNFA))
{
string str = sw.ToString();
Assert.StartsWith("<?xml version=\"1.0\" encoding=\"utf-8\"?>", str);
Assert.Contains("DirectedGraph", str);
foreach (string fragment in expectedDgmlFragments)
{
Assert.Contains(fragment, str);
}
}
static bool TrySaveDGML(Regex regex, TextWriter writer, int bound = -1, bool hideStateInfo = false, bool addDotStar = false, bool inReverse = false, bool onlyDFAinfo = false, int maxLabelLength = -1, bool asNFA = false)
{
MethodInfo saveDgml = regex.GetType().GetMethod("SaveDGML", BindingFlags.NonPublic | BindingFlags.Instance);
if (saveDgml is not null)
{
saveDgml.Invoke(regex, new object[] { writer, bound, hideStateInfo, addDotStar, inReverse, onlyDFAinfo, maxLabelLength, asNFA });
return true;
}
return false;
}
}
#region Tests involving Intersection and Complement
// Currently only run in DEBUG mode in the NonBacktracking engine
//[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
private void SRMTest_ConjuctionIsMatch()
{
try
{
var re = new Regex(And(".*a.*", ".*b.*"), RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline | RegexOptions.IgnoreCase);
bool ok = re.IsMatch("xxaaxxBxaa");
Assert.True(ok);
bool fail = re.IsMatch("xxaaxxcxaa");
Assert.False(fail);
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
//[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
private void SRMTest_ConjuctionFindMatch()
{
try
{
// contains lower, upper, and a digit, and is between 2 and 4 characters long
var re = new Regex(And(".*[a-z].*", ".*[A-Z].*", ".*[0-9].*", ".{2,4}"), RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
var match = re.Match("xxaac\n5Bxaa");
Assert.True(match.Success);
Assert.Equal(4, match.Index);
Assert.Equal(4, match.Length);
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
//[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
private void SRMTest_ComplementFindMatch()
{
try
{
// contains lower, upper, and a digit, and is between 4 and 8 characters long, does not contain 2 consequtive digits
var re = new Regex(And(".*[a-z].*", ".*[A-Z].*", ".*[0-9].*", ".{4,8}",
Not(".*(?:01|12|23|34|45|56|67|78|89).*")), RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
var match = re.Match("xxaac12Bxaas3455");
Assert.True(match.Success);
Assert.Equal(6, match.Index);
Assert.Equal(7, match.Length);
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
//[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
private void PasswordSearch()
{
try
{
string twoLower = ".*[a-z].*[a-z].*";
string twoUpper = ".*[A-Z].*[A-Z].*";
string threeDigits = ".*[0-9].*[0-9].*[0-9].*";
string oneSpecial = @".*[\x21-\x2F\x3A-\x40\x5B-x60\x7B-\x7E].*";
string Not_countUp = Not(".*(?:012|123|234|345|456|567|678|789).*");
string Not_countDown = Not(".*(?:987|876|765|654|543|432|321|210).*");
// Observe that the space character (immediately before '!' in ASCII) is excluded
string length = "[!-~]{8,12}";
// Just to make the chance that the randomly generated part actually has a match
// be astronomically unlikely require 'X' and 'r' to be present also,
// although this constraint is really bogus from password constraints point of view
string contains_first_P_and_then_r = ".*X.*r.*";
// Conjunction of all the above constraints
string all = And(twoLower, twoUpper, threeDigits, oneSpecial, Not_countUp, Not_countDown, length, contains_first_P_and_then_r);
// search for the password in a context surrounded by word boundaries
Regex re = new Regex($@"\b{all}\b", RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
// Does not qualify because of 123 and connot end between 2 and 3 because of \b
string almost1 = "X@ssW0rd123";
// Does not have at least two uppercase
string almost2 = "X@55w0rd";
// These two qualify
string matching1 = "X@55W0rd";
string matching2 = "Xa5$w00rD";
foreach (int k in new int[] { 500, 1000, 5000, 10000, 50000, 100000 })
{
Random random = new(k);
byte[] buffer1 = new byte[k];
byte[] buffer2 = new byte[k];
byte[] buffer3 = new byte[k];
random.NextBytes(buffer1);
random.NextBytes(buffer2);
random.NextBytes(buffer3);
string part1 = new string(Array.ConvertAll(buffer1, b => (char)b));
string part2 = new string(Array.ConvertAll(buffer2, b => (char)b));
string part3 = new string(Array.ConvertAll(buffer3, b => (char)b));
string input = $"{part1} {almost1} {part2} {matching1} {part3} {matching2}, finally this {almost2} does not qualify either";
int expextedMatch1Index = (2 * k) + almost1.Length + 3;
int expextedMatch1Length = matching1.Length;
int expextedMatch2Index = (3 * k) + almost1.Length + matching1.Length + 5;
int expextedMatch2Length = matching2.Length;
// Random text hiding almostPassw and password
int t = System.Environment.TickCount;
Match match1 = re.Match(input);
Match match2 = match1.NextMatch();
Match match3 = match2.NextMatch();
t = System.Environment.TickCount - t;
_output.WriteLine($@"k={k}, t={t}ms");
Assert.True(match1.Success);
Assert.Equal(expextedMatch1Index, match1.Index);
Assert.Equal(expextedMatch1Length, match1.Length);
Assert.Equal(matching1, match1.Value);
Assert.True(match2.Success);
Assert.Equal(expextedMatch2Index, match2.Index);
Assert.Equal(expextedMatch2Length, match2.Length);
Assert.Equal(matching2, match2.Value);
Assert.False(match3.Success);
}
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
//[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
private void PasswordSearchDual()
{
try
{
string Not_twoLower = Not(".*[a-z].*[a-z].*");
string Not_twoUpper = Not(".*[A-Z].*[A-Z].*");
string Not_threeDigits = Not(".*[0-9].*[0-9].*[0-9].*");
string Not_oneSpecial = Not(@".*[\x21-\x2F\x3A-\x40\x5B-x60\x7B-\x7E].*");
string countUp = ".*(?:012|123|234|345|456|567|678|789).*";
string countDown = ".*(?:987|876|765|654|543|432|321|210).*";
// Observe that the space character (immediately before '!' in ASCII) is excluded
string Not_length = Not("[!-~]{8,12}");
// Just to make the chance that the randomly generated part actually has a match
// be astronomically unlikely require 'P' and 'r' to be present also,
// although this constraint is really bogus from password constraints point of view
string Not_contains_first_P_and_then_r = Not(".*X.*r.*");
// Negated disjunction of all the above constraints
// By deMorgan's laws we know that ~(A|B|...|C) = ~A&~B&...&~C and ~~A = A
// So Not(Not_twoLower|...) is equivalent to twoLower&~(...)
string all = Not($"{Not_twoLower}|{Not_twoUpper}|{Not_threeDigits}|{Not_oneSpecial}|{countUp}|{countDown}|{Not_length}|{Not_contains_first_P_and_then_r}");
// search for the password in a context surrounded by word boundaries
Regex re = new Regex($@"\b{all}\b", RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
// Does not qualify because of 123 and connot end between 2 and 3 because of \b
string almost1 = "X@ssW0rd123";
// Does not have at least two uppercase
string almost2 = "X@55w0rd";
// These two qualify
string matching1 = "X@55W0rd";
string matching2 = "Xa5$w00rD";
foreach (int k in new int[] { 500, 1000, 5000, 10000, 50000, 100000 })
{
Random random = new(k);
byte[] buffer1 = new byte[k];
byte[] buffer2 = new byte[k];
byte[] buffer3 = new byte[k];
random.NextBytes(buffer1);
random.NextBytes(buffer2);
random.NextBytes(buffer3);
string part1 = new string(Array.ConvertAll(buffer1, b => (char)b));
string part2 = new string(Array.ConvertAll(buffer2, b => (char)b));
string part3 = new string(Array.ConvertAll(buffer3, b => (char)b));
string input = $"{part1} {almost1} {part2} {matching1} {part3} {matching2}, finally this {almost2} does not qualify either";
int expectedMatch1Index = (2 * k) + almost1.Length + 3;
int expectedMatch1Length = matching1.Length;
int expectedMatch2Index = (3 * k) + almost1.Length + matching1.Length + 5;
int expectedMatch2Length = matching2.Length;
// Random text hiding almost and matching strings
int t = System.Environment.TickCount;
Match match1 = re.Match(input);
Match match2 = match1.NextMatch();
Match match3 = match2.NextMatch();
t = System.Environment.TickCount - t;
_output.WriteLine($@"k={k}, t={t}ms");
Assert.True(match1.Success);
Assert.Equal(expectedMatch1Index, match1.Index);
Assert.Equal(expectedMatch1Length, match1.Length);
Assert.Equal(matching1, match1.Value);
Assert.True(match2.Success);
Assert.Equal(expectedMatch2Index, match2.Index);
Assert.Equal(expectedMatch2Length, match2.Length);
Assert.Equal(matching2, match2.Value);
Assert.False(match3.Success);
}
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
//[ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
//[InlineData("[abc]{0,10}", "a[abc]{0,3}", "xxxabbbbbbbyyy", true, "abbb")]
//[InlineData("[abc]{0,10}?", "a[abc]{0,3}?", "xxxabbbbbbbyyy", true, "a")]
private void TestConjunctionOverCounting(string conjunct1, string conjunct2, string input, bool success, string match)
{
try
{
string pattern = And(conjunct1, conjunct2);
Regex re = new Regex(pattern, RegexHelpers.RegexOptionNonBacktracking);
Match m = re.Match(input);
Assert.Equal(success, m.Success);
Assert.Equal(match, m.Value);
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
#endregion
#region Random input generation tests
public static IEnumerable<object[]> GenerateRandomMembers_TestData()
{
string[] patterns = new string[] { @"pa[5\$s]{2}w[o0]rd$", @"\w\d+", @"\d{10}" };
foreach (string pattern in patterns)
{
Regex re = new Regex(pattern, RegexHelpers.RegexOptionNonBacktracking);
foreach (bool negative in new bool[] { false, true })
{
// Generate 3 positive and 3 negative inputs
List<string> inputs = new(GenerateRandomMembersViaReflection(re, 3, 123, negative));
foreach (RegexEngine engine in RegexHelpers.AvailableEngines)
{
foreach (string input in inputs)
{
yield return new object[] { engine, pattern, input, !negative };
}
}
}
}
}
/// <summary>Test random input generation correctness</summary>
[ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
[MemberData(nameof(GenerateRandomMembers_TestData))]
public async Task GenerateRandomMembers(RegexEngine engine, string pattern, string input, bool isMatch)
{
Regex regex = await RegexHelpers.GetRegexAsync(engine, pattern);
Assert.Equal(isMatch, regex.IsMatch(input));
}
private static IEnumerable<string> GenerateRandomMembersViaReflection(Regex regex, int how_many_inputs, int randomseed, bool negative)
{
MethodInfo? gen = regex.GetType().GetMethod("GenerateRandomMembers", BindingFlags.NonPublic | BindingFlags.Instance);
if (gen is not null)
{
return (IEnumerable<string>)gen.Invoke(regex, new object[] { how_many_inputs, randomseed, negative });
}
else
{
return new string[] { };
}
}
#endregion
}
}
|
// Licensed to the .NET Foundation under one or more agreements.if #DEBUG
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using Xunit;
using Xunit.Abstractions;
using System.Threading.Tasks;
using System.Diagnostics.CodeAnalysis;
namespace System.Text.RegularExpressions.Tests
{
/// <summary>
/// This class is to be ignored wrt unit tests in Release mode.
/// It contains temporary experimental code, such as lightweight profiling and debuggging locally.
/// Set <see cref="Enabled"/> to true to run all the tests.
/// </summary>
public class RegexExperiment
{
private readonly ITestOutputHelper _output;
public RegexExperiment(ITestOutputHelper output) => _output = output;
public static bool Enabled => false;
/// <summary>Temporary local output directory for experiment results.</summary>
private static readonly string s_tmpWorkingDir = Path.GetTempPath();
/// <summary>Works as a console.</summary>
private static string OutputFilePath => Path.Combine(s_tmpWorkingDir, "vsoutput.txt");
/// <summary>Output directory for generated dgml files.</summary>
private static string DgmlOutputDirectoryPath => Path.Combine(s_tmpWorkingDir, "dgml");
[Fact]
public void RegenerateUnicodeTables()
{
if (!Enabled)
{
return;
}
MethodInfo? genUnicode = typeof(Regex).GetMethod("GenerateUnicodeTables", BindingFlags.NonPublic | BindingFlags.Static);
// GenerateUnicodeTables is not available in Release build
if (genUnicode is not null)
{
genUnicode.Invoke(null, new object[] { s_tmpWorkingDir });
}
}
private static long MeasureMatchTime(Regex re, string input, out Match match)
{
try
{
var sw = Stopwatch.StartNew();
match = re.Match(input);
return sw.ElapsedMilliseconds;
}
catch (RegexMatchTimeoutException)
{
match = Match.Empty;
return -1;
}
catch (Exception)
{
match = Match.Empty;
return -2;
}
}
/// <summary>
/// Creates a regex that in the NonBacktracking engine in DEBUG mode represents intersection of regexes
/// </summary>
private static string And(params string[] regexes)
{
string conj = $"(?:{regexes[regexes.Length - 1]})";
for (int i = regexes.Length - 2; i >= 0; i--)
{
conj = $"(?({regexes[i]}){conj}|[0-[0]])";
}
return conj;
}
/// <summary>
/// Creates a regex that in the NonBacktracking engine in DEBUG mode represents complement of regex
/// </summary>
private static string Not(string regex) => $"(?({regex})[0-[0]]|.*)";
/// <summary>
/// When <see cref="Enabled"/> is set to return true, outputs DGML diagrams for the specified pattern.
/// This is useful for understanding what graphs the NonBacktracking engine creates for the specified pattern.
/// </summary>
[Fact]
public void ViewSampleRegexInDGML()
{
if (!Enabled)
{
return;
}
if (!Directory.Exists(DgmlOutputDirectoryPath))
{
Directory.CreateDirectory(DgmlOutputDirectoryPath);
}
try
{
/*lang=regex*/
string pattern = @"abc|cd";
ViewDGML(pattern, "DFA");
ViewDGML(pattern, "DFA_DotStar", addDotStar: true);
ViewDGML(pattern, "NFA", nfa: true, maxStates: 12);
ViewDGML(pattern, "NFA_DotStar", nfa: true, addDotStar: true, maxStates: 12);
static void ViewDGML(string pattern, string name, bool nfa = false, bool addDotStar = false, bool reverse = false, int maxStates = -1, int maxLabelLength = 20)
{
var regex = new Regex(pattern, RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
if (regex.GetType().GetMethod("SaveDGML", BindingFlags.NonPublic | BindingFlags.Instance) is MethodInfo saveDgml)
{
var sw = new StringWriter();
saveDgml.Invoke(regex, new object[] { sw, nfa, addDotStar, reverse, maxStates, maxLabelLength });
string path = Path.Combine(DgmlOutputDirectoryPath, $"{name}.dgml");
File.WriteAllText(path, sw.ToString());
Console.WriteLine(path);
}
}
}
catch (NotSupportedException e) when (e.Message.Contains("conditional"))
{
}
}
[ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
[InlineData(".*a+", -1, new string[] { ".*a+" }, false, false)]
[InlineData("ann", -1, new string[] { "nna" }, true, false)]
[InlineData("(something|otherstuff)+", 10, new string[] { "Unexplored", "some" }, false, true)]
[InlineData("(something|otherstuff)+", 10, new string[] { "Unexplored", "ffut" }, true, true)]
public void TestDGMLGeneration(string pattern, int explorationbound, string[] expectedDgmlFragments, bool exploreInReverse, bool exploreAsNFA)
{
StringWriter sw = new StringWriter();
var re = new Regex(pattern, RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
if (TrySaveDGML(re, sw, exploreAsNFA, addDotStar: false, exploreInReverse, explorationbound, maxLabelLength: -1))
{
string str = sw.ToString();
Assert.StartsWith("<?xml version=\"1.0\" encoding=\"utf-8\"?>", str);
Assert.Contains("DirectedGraph", str);
foreach (string fragment in expectedDgmlFragments)
{
Assert.Contains(fragment, str);
}
}
static bool TrySaveDGML(Regex regex, TextWriter writer, bool nfa, bool addDotStar, bool reverse, int maxStates, int maxLabelLength)
{
MethodInfo saveDgml = regex.GetType().GetMethod("SaveDGML", BindingFlags.NonPublic | BindingFlags.Instance);
if (saveDgml is not null)
{
saveDgml.Invoke(regex, new object[] { writer, nfa, addDotStar, reverse, maxStates, maxLabelLength });
return true;
}
return false;
}
}
#region Tests involving Intersection and Complement
// Currently only run in DEBUG mode in the NonBacktracking engine
//[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
private void SRMTest_ConjuctionIsMatch()
{
try
{
var re = new Regex(And(".*a.*", ".*b.*"), RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline | RegexOptions.IgnoreCase);
bool ok = re.IsMatch("xxaaxxBxaa");
Assert.True(ok);
bool fail = re.IsMatch("xxaaxxcxaa");
Assert.False(fail);
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
//[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
private void SRMTest_ConjuctionFindMatch()
{
try
{
// contains lower, upper, and a digit, and is between 2 and 4 characters long
var re = new Regex(And(".*[a-z].*", ".*[A-Z].*", ".*[0-9].*", ".{2,4}"), RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
var match = re.Match("xxaac\n5Bxaa");
Assert.True(match.Success);
Assert.Equal(4, match.Index);
Assert.Equal(4, match.Length);
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
//[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
private void SRMTest_ComplementFindMatch()
{
try
{
// contains lower, upper, and a digit, and is between 4 and 8 characters long, does not contain 2 consequtive digits
var re = new Regex(And(".*[a-z].*", ".*[A-Z].*", ".*[0-9].*", ".{4,8}",
Not(".*(?:01|12|23|34|45|56|67|78|89).*")), RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
var match = re.Match("xxaac12Bxaas3455");
Assert.True(match.Success);
Assert.Equal(6, match.Index);
Assert.Equal(7, match.Length);
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
//[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
private void PasswordSearch()
{
try
{
string twoLower = ".*[a-z].*[a-z].*";
string twoUpper = ".*[A-Z].*[A-Z].*";
string threeDigits = ".*[0-9].*[0-9].*[0-9].*";
string oneSpecial = @".*[\x21-\x2F\x3A-\x40\x5B-x60\x7B-\x7E].*";
string Not_countUp = Not(".*(?:012|123|234|345|456|567|678|789).*");
string Not_countDown = Not(".*(?:987|876|765|654|543|432|321|210).*");
// Observe that the space character (immediately before '!' in ASCII) is excluded
string length = "[!-~]{8,12}";
// Just to make the chance that the randomly generated part actually has a match
// be astronomically unlikely require 'X' and 'r' to be present also,
// although this constraint is really bogus from password constraints point of view
string contains_first_P_and_then_r = ".*X.*r.*";
// Conjunction of all the above constraints
string all = And(twoLower, twoUpper, threeDigits, oneSpecial, Not_countUp, Not_countDown, length, contains_first_P_and_then_r);
// search for the password in a context surrounded by word boundaries
Regex re = new Regex($@"\b{all}\b", RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
// Does not qualify because of 123 and connot end between 2 and 3 because of \b
string almost1 = "X@ssW0rd123";
// Does not have at least two uppercase
string almost2 = "X@55w0rd";
// These two qualify
string matching1 = "X@55W0rd";
string matching2 = "Xa5$w00rD";
foreach (int k in new int[] { 500, 1000, 5000, 10000, 50000, 100000 })
{
Random random = new(k);
byte[] buffer1 = new byte[k];
byte[] buffer2 = new byte[k];
byte[] buffer3 = new byte[k];
random.NextBytes(buffer1);
random.NextBytes(buffer2);
random.NextBytes(buffer3);
string part1 = new string(Array.ConvertAll(buffer1, b => (char)b));
string part2 = new string(Array.ConvertAll(buffer2, b => (char)b));
string part3 = new string(Array.ConvertAll(buffer3, b => (char)b));
string input = $"{part1} {almost1} {part2} {matching1} {part3} {matching2}, finally this {almost2} does not qualify either";
int expextedMatch1Index = (2 * k) + almost1.Length + 3;
int expextedMatch1Length = matching1.Length;
int expextedMatch2Index = (3 * k) + almost1.Length + matching1.Length + 5;
int expextedMatch2Length = matching2.Length;
// Random text hiding almostPassw and password
int t = System.Environment.TickCount;
Match match1 = re.Match(input);
Match match2 = match1.NextMatch();
Match match3 = match2.NextMatch();
t = System.Environment.TickCount - t;
_output.WriteLine($@"k={k}, t={t}ms");
Assert.True(match1.Success);
Assert.Equal(expextedMatch1Index, match1.Index);
Assert.Equal(expextedMatch1Length, match1.Length);
Assert.Equal(matching1, match1.Value);
Assert.True(match2.Success);
Assert.Equal(expextedMatch2Index, match2.Index);
Assert.Equal(expextedMatch2Length, match2.Length);
Assert.Equal(matching2, match2.Value);
Assert.False(match3.Success);
}
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
//[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
private void PasswordSearchDual()
{
try
{
string Not_twoLower = Not(".*[a-z].*[a-z].*");
string Not_twoUpper = Not(".*[A-Z].*[A-Z].*");
string Not_threeDigits = Not(".*[0-9].*[0-9].*[0-9].*");
string Not_oneSpecial = Not(@".*[\x21-\x2F\x3A-\x40\x5B-x60\x7B-\x7E].*");
string countUp = ".*(?:012|123|234|345|456|567|678|789).*";
string countDown = ".*(?:987|876|765|654|543|432|321|210).*";
// Observe that the space character (immediately before '!' in ASCII) is excluded
string Not_length = Not("[!-~]{8,12}");
// Just to make the chance that the randomly generated part actually has a match
// be astronomically unlikely require 'P' and 'r' to be present also,
// although this constraint is really bogus from password constraints point of view
string Not_contains_first_P_and_then_r = Not(".*X.*r.*");
// Negated disjunction of all the above constraints
// By deMorgan's laws we know that ~(A|B|...|C) = ~A&~B&...&~C and ~~A = A
// So Not(Not_twoLower|...) is equivalent to twoLower&~(...)
string all = Not($"{Not_twoLower}|{Not_twoUpper}|{Not_threeDigits}|{Not_oneSpecial}|{countUp}|{countDown}|{Not_length}|{Not_contains_first_P_and_then_r}");
// search for the password in a context surrounded by word boundaries
Regex re = new Regex($@"\b{all}\b", RegexHelpers.RegexOptionNonBacktracking | RegexOptions.Singleline);
// Does not qualify because of 123 and connot end between 2 and 3 because of \b
string almost1 = "X@ssW0rd123";
// Does not have at least two uppercase
string almost2 = "X@55w0rd";
// These two qualify
string matching1 = "X@55W0rd";
string matching2 = "Xa5$w00rD";
foreach (int k in new int[] { 500, 1000, 5000, 10000, 50000, 100000 })
{
Random random = new(k);
byte[] buffer1 = new byte[k];
byte[] buffer2 = new byte[k];
byte[] buffer3 = new byte[k];
random.NextBytes(buffer1);
random.NextBytes(buffer2);
random.NextBytes(buffer3);
string part1 = new string(Array.ConvertAll(buffer1, b => (char)b));
string part2 = new string(Array.ConvertAll(buffer2, b => (char)b));
string part3 = new string(Array.ConvertAll(buffer3, b => (char)b));
string input = $"{part1} {almost1} {part2} {matching1} {part3} {matching2}, finally this {almost2} does not qualify either";
int expectedMatch1Index = (2 * k) + almost1.Length + 3;
int expectedMatch1Length = matching1.Length;
int expectedMatch2Index = (3 * k) + almost1.Length + matching1.Length + 5;
int expectedMatch2Length = matching2.Length;
// Random text hiding almost and matching strings
int t = System.Environment.TickCount;
Match match1 = re.Match(input);
Match match2 = match1.NextMatch();
Match match3 = match2.NextMatch();
t = System.Environment.TickCount - t;
_output.WriteLine($@"k={k}, t={t}ms");
Assert.True(match1.Success);
Assert.Equal(expectedMatch1Index, match1.Index);
Assert.Equal(expectedMatch1Length, match1.Length);
Assert.Equal(matching1, match1.Value);
Assert.True(match2.Success);
Assert.Equal(expectedMatch2Index, match2.Index);
Assert.Equal(expectedMatch2Length, match2.Length);
Assert.Equal(matching2, match2.Value);
Assert.False(match3.Success);
}
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
//[ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
//[InlineData("[abc]{0,10}", "a[abc]{0,3}", "xxxabbbbbbbyyy", true, "abbb")]
//[InlineData("[abc]{0,10}?", "a[abc]{0,3}?", "xxxabbbbbbbyyy", true, "a")]
private void TestConjunctionOverCounting(string conjunct1, string conjunct2, string input, bool success, string match)
{
try
{
string pattern = And(conjunct1, conjunct2);
Regex re = new Regex(pattern, RegexHelpers.RegexOptionNonBacktracking);
Match m = re.Match(input);
Assert.Equal(success, m.Success);
Assert.Equal(match, m.Value);
}
catch (NotSupportedException e)
{
// In Release build (?( test-pattern ) yes-pattern | no-pattern ) is not supported
Assert.Contains("conditional", e.Message);
}
}
#endregion
#region Random input generation tests
public static IEnumerable<object[]> GenerateRandomMembers_TestData()
{
string[] patterns = new string[] { @"pa[5\$s]{2}w[o0]rd$", @"\w\d+", @"\d{10}" };
foreach (string pattern in patterns)
{
Regex re = new Regex(pattern, RegexHelpers.RegexOptionNonBacktracking);
foreach (bool negative in new bool[] { false, true })
{
// Generate 3 positive and 3 negative inputs
List<string> inputs = new(GenerateRandomMembersViaReflection(re, 3, 123, negative));
foreach (RegexEngine engine in RegexHelpers.AvailableEngines)
{
foreach (string input in inputs)
{
yield return new object[] { engine, pattern, input, !negative };
}
}
}
}
}
/// <summary>Test random input generation correctness</summary>
[ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
[MemberData(nameof(GenerateRandomMembers_TestData))]
public async Task GenerateRandomMembers(RegexEngine engine, string pattern, string input, bool isMatch)
{
Regex regex = await RegexHelpers.GetRegexAsync(engine, pattern);
Assert.Equal(isMatch, regex.IsMatch(input));
}
private static IEnumerable<string> GenerateRandomMembersViaReflection(Regex regex, int how_many_inputs, int randomseed, bool negative)
{
MethodInfo? gen = regex.GetType().GetMethod("GenerateRandomMembers", BindingFlags.NonPublic | BindingFlags.Instance);
if (gen is not null)
{
return (IEnumerable<string>)gen.Invoke(regex, new object[] { how_many_inputs, randomseed, negative });
}
else
{
return new string[] { };
}
}
#endregion
}
}
| 1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/RegexRunnerTests.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Reflection;
using System.Threading.Tasks;
using Xunit;
namespace System.Text.RegularExpressions.Tests
{
public class RegexRunnerTests
{
[Theory]
[MemberData(nameof(RegexHelpers.AvailableEngines_MemberData), MemberType = typeof(RegexHelpers))]
public async Task EnginesThrowNotImplementedForGoAndFFC(RegexEngine engine)
{
Regex re = await RegexHelpers.GetRegexAsync(engine, /*lang=regex*/@"abc");
// Use reflection to ensure the runner is created so it can be fetched.
MethodInfo createRunnerMethod = typeof(Regex).GetMethod("CreateRunner", BindingFlags.Instance | BindingFlags.NonPublic);
RegexRunner runner = createRunnerMethod.Invoke(re, new object[] { }) as RegexRunner;
// Use reflection to call Go and FFC and ensure it throws NotImplementedException
MethodInfo goMethod = typeof(RegexRunner).GetMethod("Go", BindingFlags.Instance | BindingFlags.NonPublic);
MethodInfo ffcMethod = typeof(RegexRunner).GetMethod("FindFirstChar", BindingFlags.Instance | BindingFlags.NonPublic);
// FindFirstChar and Go methods should not be implemented since built-in engines should be overriding and using Scan instead.
TargetInvocationException goInvocationException = Assert.Throws<TargetInvocationException>(() => goMethod.Invoke(runner, new object[] { }));
Assert.Equal(typeof(NotImplementedException), goInvocationException.InnerException.GetType());
TargetInvocationException ffcInvocationException = Assert.Throws<TargetInvocationException>(() => ffcMethod.Invoke(runner, new object[] { }));
Assert.Equal(typeof(NotImplementedException), ffcInvocationException.InnerException.GetType());
}
[Theory]
[MemberData(nameof(RegexHelpers.AvailableEngines_MemberData), MemberType = typeof(RegexHelpers))]
public async Task EnsureRunmatchValueIsNulledAfterIsMatch(RegexEngine engine)
{
Regex re = await RegexHelpers.GetRegexAsync(engine, /*lang=regex*/@"abc");
// First call IsMatch which should initialize runmatch on the runner.
Assert.True(re.IsMatch("abcabcabc"));
// Ensure runmatch wasn't nulled out, since after calling IsMatch it should be reused.
FieldInfo runnerField = typeof(Regex).GetField("_runner", BindingFlags.Instance | BindingFlags.NonPublic);
RegexRunner runner = runnerField.GetValue(re) as RegexRunner;
FieldInfo runmatchField = typeof(RegexRunner).GetField("runmatch", BindingFlags.Instance | BindingFlags.NonPublic);
Match runmatch = runmatchField.GetValue(runner) as Match;
Assert.NotNull(runmatch);
// Ensure that the Value of runmatch was nulled out, so as to not keep a reference to it in a cache.
MethodInfo getTextMethod = typeof(Match).GetMethod("get_Text", BindingFlags.Instance | BindingFlags.NonPublic);
Assert.Null(getTextMethod.Invoke(runmatch, new object[] { }));
Assert.Equal(string.Empty, runmatch.Value);
#if NET7_0_OR_GREATER
Assert.True(runmatch.ValueSpan == ReadOnlySpan<char>.Empty);
#endif
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Reflection;
using System.Threading.Tasks;
using Xunit;
namespace System.Text.RegularExpressions.Tests
{
public class RegexRunnerTests
{
[Theory]
[MemberData(nameof(RegexHelpers.AvailableEngines_MemberData), MemberType = typeof(RegexHelpers))]
public async Task EnginesThrowNotImplementedForGoAndFFC(RegexEngine engine)
{
Regex re = await RegexHelpers.GetRegexAsync(engine, @"abc");
// Use reflection to ensure the runner is created so it can be fetched.
MethodInfo createRunnerMethod = typeof(Regex).GetMethod("CreateRunner", BindingFlags.Instance | BindingFlags.NonPublic);
RegexRunner runner = createRunnerMethod.Invoke(re, new object[] { }) as RegexRunner;
// Use reflection to call Go and FFC and ensure it throws NotImplementedException
MethodInfo goMethod = typeof(RegexRunner).GetMethod("Go", BindingFlags.Instance | BindingFlags.NonPublic);
MethodInfo ffcMethod = typeof(RegexRunner).GetMethod("FindFirstChar", BindingFlags.Instance | BindingFlags.NonPublic);
// FindFirstChar and Go methods should not be implemented since built-in engines should be overriding and using Scan instead.
TargetInvocationException goInvocationException = Assert.Throws<TargetInvocationException>(() => goMethod.Invoke(runner, new object[] { }));
Assert.Equal(typeof(NotImplementedException), goInvocationException.InnerException.GetType());
TargetInvocationException ffcInvocationException = Assert.Throws<TargetInvocationException>(() => ffcMethod.Invoke(runner, new object[] { }));
Assert.Equal(typeof(NotImplementedException), ffcInvocationException.InnerException.GetType());
}
[Theory]
[MemberData(nameof(RegexHelpers.AvailableEngines_MemberData), MemberType = typeof(RegexHelpers))]
public async Task EnsureRunmatchValueIsNulledAfterIsMatch(RegexEngine engine)
{
Regex re = await RegexHelpers.GetRegexAsync(engine, @"abc");
// First call IsMatch which should initialize runmatch on the runner.
Assert.True(re.IsMatch("abcabcabc"));
// Ensure runmatch wasn't nulled out, since after calling IsMatch it should be reused.
FieldInfo runnerField = typeof(Regex).GetField("_runner", BindingFlags.Instance | BindingFlags.NonPublic);
RegexRunner runner = runnerField.GetValue(re) as RegexRunner;
FieldInfo runmatchField = typeof(RegexRunner).GetField("runmatch", BindingFlags.Instance | BindingFlags.NonPublic);
Match runmatch = runmatchField.GetValue(runner) as Match;
Assert.NotNull(runmatch);
// Ensure that the Value of runmatch was nulled out, so as to not keep a reference to it in a cache.
MethodInfo getTextMethod = typeof(Match).GetMethod("get_Text", BindingFlags.Instance | BindingFlags.NonPublic);
Assert.Null(getTextMethod.Invoke(runmatch, new object[] { }));
Assert.Equal(string.Empty, runmatch.Value);
#if NET7_0_OR_GREATER
Assert.True(runmatch.ValueSpan == ReadOnlySpan<char>.Empty);
#endif
}
}
}
| 1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/System.Text.RegularExpressions.Tests.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<IncludeRemoteExecutor>true</IncludeRemoteExecutor>
<!-- xUnit2008 is about regexes and isn't appropriate in the test project for regexes -->
<!-- SYSLIB0036 is about obsoletion of regex members -->
<NoWarn>$(NoWarn);xUnit2008;SYSLIB0036</NoWarn>
<TargetFrameworks>$(NetCoreAppCurrent);net48</TargetFrameworks>
<DebuggerSupport Condition="'$(DebuggerSupport)' == '' and '$(TargetOS)' == 'Browser'">true</DebuggerSupport>
<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
<IsHighAotMemoryUsageTest>true</IsHighAotMemoryUsageTest> <!-- to avoid OOMs with source generation in wasm: https://github.com/dotnet/runtime/pull/60701 -->
</PropertyGroup>
<ItemGroup>
<Compile Include="AttRegexTests.cs" />
<Compile Include="CaptureCollectionTests.cs" />
<Compile Include="GroupCollectionTests.cs" />
<Compile Include="MatchCollectionTests.cs" />
<Compile Include="MonoRegexTests.cs" />
<Compile Include="Regex.CompileToAssembly.Tests.cs" />
<Compile Include="Regex.Ctor.Tests.cs" />
<Compile Include="Regex.Cache.Tests.cs" />
<Compile Include="Regex.EscapeUnescape.Tests.cs" />
<Compile Include="Regex.GetGroupNames.Tests.cs" />
<Compile Include="Regex.Groups.Tests.cs" />
<Compile Include="Regex.KnownPattern.Tests.cs" />
<Compile Include="Regex.Match.Tests.cs" />
<Compile Include="Regex.MultipleMatches.Tests.cs" />
<Compile Include="Regex.Replace.Tests.cs" />
<Compile Include="Regex.Split.Tests.cs" />
<Compile Include="Regex.Tests.Common.cs" />
<Compile Include="Regex.UnicodeChar.Tests.cs" />
<Compile Include="RegexCharacterSetTests.cs" />
<Compile Include="RegexCultureTests.cs" />
<Compile Include="RegexMatchTimeoutExceptionTests.cs" />
<Compile Include="RegexParserTests.cs" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'net48'">
<Compile Include="..\..\src\System\Text\RegularExpressions\RegexParseError.cs" Link="System\Text\RegularExpressions\RegexParseError.cs" />
<Compile Include="RegexAssert.netfx.cs" />
<Compile Include="RegexParserTests.netfx.cs" />
<Compile Include="RegexGeneratorHelper.netfx.cs" />
<PackageReference Include="System.Text.Json" Version="$(SystemTextJsonVersion)" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
<Compile Include="CustomDerivedRegexScenarioTest.cs" />
<Compile Include="RegexRunnerTests.cs" />
<Compile Include="Regex.Count.Tests.cs" />
<Compile Include="RegexAssert.netcoreapp.cs" />
<Compile Include="RegexParserTests.netcoreapp.cs" />
<Compile Include="GroupCollectionReadOnlyDictionaryTests.cs" />
<Compile Include="CaptureCollectionTests2.cs" />
<Compile Include="GroupCollectionTests2.cs" />
<Compile Include="MatchCollectionTests2.cs" />
<Compile Include="PrecompiledRegexScenarioTest.cs" />
<Compile Include="RegexCompilationInfoTests.cs" />
<Compile Include="RegexGeneratorAttributeTests.cs" />
<Compile Include="RegexGeneratorParserTests.cs" />
<Compile Include="RegexGroupNameTests.cs" />
<Compile Include="RegexExperiment.cs" />
<Compile Include="RegexGeneratorHelper.netcoreapp.cs" />
<Compile Include="$(CommonTestPath)System\Diagnostics\DebuggerAttributes.cs" Link="Common\System\Diagnostics\DebuggerAttributes.cs" />
<PackageReference Include="Microsoft.CodeAnalysis" Version="$(MicrosoftCodeAnalysisVersion)" />
<ProjectReference Include="..\..\gen\System.Text.RegularExpressions.Generator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="true" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="System.Text.RegularExpressions.TestData" Version="$(SystemTextRegularExpressionsTestDataVersion)" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<IncludeRemoteExecutor>true</IncludeRemoteExecutor>
<!-- xUnit2008 is about regexes and isn't appropriate in the test project for regexes -->
<!-- SYSLIB0036 is about obsoletion of regex members -->
<NoWarn>$(NoWarn);xUnit2008;SYSLIB0036</NoWarn>
<TargetFrameworks>$(NetCoreAppCurrent);net48</TargetFrameworks>
<DebuggerSupport Condition="'$(DebuggerSupport)' == '' and '$(TargetOS)' == 'Browser'">true</DebuggerSupport>
<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
<IsHighAotMemoryUsageTest>true</IsHighAotMemoryUsageTest> <!-- to avoid OOMs with source generation in wasm: https://github.com/dotnet/runtime/pull/60701 -->
</PropertyGroup>
<ItemGroup>
<Compile Include="AttRegexTests.cs" />
<Compile Include="CaptureCollectionTests.cs" />
<Compile Include="GroupCollectionTests.cs" />
<Compile Include="MatchCollectionTests.cs" />
<Compile Include="MonoRegexTests.cs" />
<Compile Include="Regex.CompileToAssembly.Tests.cs" />
<Compile Include="Regex.Ctor.Tests.cs" />
<Compile Include="Regex.Cache.Tests.cs" />
<Compile Include="Regex.EscapeUnescape.Tests.cs" />
<Compile Include="Regex.GetGroupNames.Tests.cs" />
<Compile Include="Regex.Groups.Tests.cs" />
<Compile Include="Regex.KnownPattern.Tests.cs" />
<Compile Include="Regex.Match.Tests.cs" />
<Compile Include="Regex.MultipleMatches.Tests.cs" />
<Compile Include="Regex.Replace.Tests.cs" />
<Compile Include="Regex.Split.Tests.cs" />
<Compile Include="Regex.Tests.Common.cs" />
<Compile Include="Regex.UnicodeChar.Tests.cs" />
<Compile Include="RegexCharacterSetTests.cs" />
<Compile Include="RegexCultureTests.cs" />
<Compile Include="RegexMatchTimeoutExceptionTests.cs" />
<Compile Include="RegexParserTests.cs" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'net48'">
<Compile Include="..\..\src\System\Text\RegularExpressions\RegexParseError.cs" Link="System\Text\RegularExpressions\RegexParseError.cs" />
<Compile Include="RegexAssert.netfx.cs" />
<Compile Include="RegexParserTests.netfx.cs" />
<Compile Include="RegexGeneratorHelper.netfx.cs" />
<Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\StringSyntaxAttribute.cs" />
<PackageReference Include="System.Text.Json" Version="$(SystemTextJsonVersion)" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
<Compile Include="CustomDerivedRegexScenarioTest.cs" />
<Compile Include="RegexRunnerTests.cs" />
<Compile Include="Regex.Count.Tests.cs" />
<Compile Include="RegexAssert.netcoreapp.cs" />
<Compile Include="RegexParserTests.netcoreapp.cs" />
<Compile Include="GroupCollectionReadOnlyDictionaryTests.cs" />
<Compile Include="CaptureCollectionTests2.cs" />
<Compile Include="GroupCollectionTests2.cs" />
<Compile Include="MatchCollectionTests2.cs" />
<Compile Include="PrecompiledRegexScenarioTest.cs" />
<Compile Include="RegexCompilationInfoTests.cs" />
<Compile Include="RegexGeneratorAttributeTests.cs" />
<Compile Include="RegexGeneratorParserTests.cs" />
<Compile Include="RegexGroupNameTests.cs" />
<Compile Include="RegexExperiment.cs" />
<Compile Include="RegexGeneratorHelper.netcoreapp.cs" />
<Compile Include="$(CommonTestPath)System\Diagnostics\DebuggerAttributes.cs" Link="Common\System\Diagnostics\DebuggerAttributes.cs" />
<PackageReference Include="Microsoft.CodeAnalysis" Version="$(MicrosoftCodeAnalysisVersion)" />
<ProjectReference Include="..\..\gen\System.Text.RegularExpressions.Generator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="true" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="System.Text.RegularExpressions.TestData" Version="$(SystemTextRegularExpressionsTestDataVersion)" />
</ItemGroup>
</Project>
| 1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/Common/src/Interop/Windows/Ole32/Interop.STGTY.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
internal static partial class Interop
{
internal static partial class Ole32
{
/// <summary>
/// Type of the storage element. Used with <see cref="STATSTG"/>.
/// <see href="https://docs.microsoft.com/en-us/windows/desktop/api/objidl/ne-objidl-tagstgty"/>
/// </summary>
internal enum STGTY : uint
{
STGTY_STORAGE = 1,
STGTY_STREAM = 2,
STGTY_LOCKBYTES = 3,
STGTY_PROPERTY = 4
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
internal static partial class Interop
{
internal static partial class Ole32
{
/// <summary>
/// Type of the storage element. Used with <see cref="STATSTG"/>.
/// <see href="https://docs.microsoft.com/en-us/windows/desktop/api/objidl/ne-objidl-tagstgty"/>
/// </summary>
internal enum STGTY : uint
{
STGTY_STORAGE = 1,
STGTY_STREAM = 2,
STGTY_LOCKBYTES = 3,
STGTY_PROPERTY = 4
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/HardwareIntrinsics/General/Vector256_1/AsVector.SByte.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\General\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Linq;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
namespace JIT.HardwareIntrinsics.General
{
public static partial class Program
{
private static void AsVectorSByte()
{
var test = new VectorAs__AsVectorSByte();
// Validates basic functionality works
test.RunBasicScenario();
// Validates calling via reflection works
test.RunReflectionScenario();
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class VectorAs__AsVectorSByte
{
private static readonly int LargestVectorSize = 32;
private static readonly int VectorElementCount = Unsafe.SizeOf<Vector256<SByte>>() / sizeof(SByte);
private static readonly int NumericsElementCount = Unsafe.SizeOf<Vector<SByte>>() / sizeof(SByte);
public bool Succeeded { get; set; } = true;
public void RunBasicScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario));
Vector256<SByte> value;
value = Vector256.Create((sbyte)TestLibrary.Generator.GetSByte());
Vector<SByte> result = value.AsVector();
ValidateResult(result, value);
value = result.AsVector256();
ValidateResult(value, result);
}
public void RunReflectionScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario));
Vector256<SByte> value;
value = Vector256.Create((sbyte)TestLibrary.Generator.GetSByte());
object Result = typeof(Vector256)
.GetMethod(nameof(Vector256.AsVector))
.MakeGenericMethod(typeof(SByte))
.Invoke(null, new object[] { value });
ValidateResult((Vector<SByte>)(Result), value);
value = (Vector256<SByte>)typeof(Vector256)
.GetMethods()
.Where((methodInfo) => {
if (methodInfo.Name == nameof(Vector256.AsVector256))
{
var parameters = methodInfo.GetParameters();
return (parameters.Length == 1) &&
(parameters[0].ParameterType.IsGenericType) &&
(parameters[0].ParameterType.GetGenericTypeDefinition() == typeof(Vector<>));
}
return false;
})
.Single()
.MakeGenericMethod(typeof(SByte))
.Invoke(null, new object[] { Result });
ValidateResult(value, (Vector<SByte>)(Result));
}
private void ValidateResult(Vector<SByte> result, Vector256<SByte> value, [CallerMemberName] string method = "")
{
SByte[] resultElements = new SByte[NumericsElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref resultElements[0]), result);
SByte[] valueElements = new SByte[VectorElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref valueElements[0]), value);
ValidateResult(resultElements, valueElements, method);
}
private void ValidateResult(Vector256<SByte> result, Vector<SByte> value, [CallerMemberName] string method = "")
{
SByte[] resultElements = new SByte[VectorElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref resultElements[0]), result);
SByte[] valueElements = new SByte[NumericsElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref valueElements[0]), value);
ValidateResult(resultElements, valueElements, method);
}
private void ValidateResult(SByte[] resultElements, SByte[] valueElements, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (resultElements.Length <= valueElements.Length)
{
for (var i = 0; i < resultElements.Length; i++)
{
if (resultElements[i] != valueElements[i])
{
succeeded = false;
break;
}
}
}
else
{
for (var i = 0; i < valueElements.Length; i++)
{
if (resultElements[i] != valueElements[i])
{
succeeded = false;
break;
}
}
for (var i = valueElements.Length; i < resultElements.Length; i++)
{
if (resultElements[i] != default)
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"Vector256<SByte>.AsVector: {method} failed:");
TestLibrary.TestFramework.LogInformation($" value: ({string.Join(", ", valueElements)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", resultElements)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\General\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Linq;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
namespace JIT.HardwareIntrinsics.General
{
public static partial class Program
{
private static void AsVectorSByte()
{
var test = new VectorAs__AsVectorSByte();
// Validates basic functionality works
test.RunBasicScenario();
// Validates calling via reflection works
test.RunReflectionScenario();
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class VectorAs__AsVectorSByte
{
private static readonly int LargestVectorSize = 32;
private static readonly int VectorElementCount = Unsafe.SizeOf<Vector256<SByte>>() / sizeof(SByte);
private static readonly int NumericsElementCount = Unsafe.SizeOf<Vector<SByte>>() / sizeof(SByte);
public bool Succeeded { get; set; } = true;
public void RunBasicScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario));
Vector256<SByte> value;
value = Vector256.Create((sbyte)TestLibrary.Generator.GetSByte());
Vector<SByte> result = value.AsVector();
ValidateResult(result, value);
value = result.AsVector256();
ValidateResult(value, result);
}
public void RunReflectionScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario));
Vector256<SByte> value;
value = Vector256.Create((sbyte)TestLibrary.Generator.GetSByte());
object Result = typeof(Vector256)
.GetMethod(nameof(Vector256.AsVector))
.MakeGenericMethod(typeof(SByte))
.Invoke(null, new object[] { value });
ValidateResult((Vector<SByte>)(Result), value);
value = (Vector256<SByte>)typeof(Vector256)
.GetMethods()
.Where((methodInfo) => {
if (methodInfo.Name == nameof(Vector256.AsVector256))
{
var parameters = methodInfo.GetParameters();
return (parameters.Length == 1) &&
(parameters[0].ParameterType.IsGenericType) &&
(parameters[0].ParameterType.GetGenericTypeDefinition() == typeof(Vector<>));
}
return false;
})
.Single()
.MakeGenericMethod(typeof(SByte))
.Invoke(null, new object[] { Result });
ValidateResult(value, (Vector<SByte>)(Result));
}
private void ValidateResult(Vector<SByte> result, Vector256<SByte> value, [CallerMemberName] string method = "")
{
SByte[] resultElements = new SByte[NumericsElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref resultElements[0]), result);
SByte[] valueElements = new SByte[VectorElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref valueElements[0]), value);
ValidateResult(resultElements, valueElements, method);
}
private void ValidateResult(Vector256<SByte> result, Vector<SByte> value, [CallerMemberName] string method = "")
{
SByte[] resultElements = new SByte[VectorElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref resultElements[0]), result);
SByte[] valueElements = new SByte[NumericsElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref valueElements[0]), value);
ValidateResult(resultElements, valueElements, method);
}
private void ValidateResult(SByte[] resultElements, SByte[] valueElements, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (resultElements.Length <= valueElements.Length)
{
for (var i = 0; i < resultElements.Length; i++)
{
if (resultElements[i] != valueElements[i])
{
succeeded = false;
break;
}
}
}
else
{
for (var i = 0; i < valueElements.Length; i++)
{
if (resultElements[i] != valueElements[i])
{
succeeded = false;
break;
}
}
for (var i = valueElements.Length; i < resultElements.Length; i++)
{
if (resultElements[i] != default)
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"Vector256<SByte>.AsVector: {method} failed:");
TestLibrary.TestFramework.LogInformation($" value: ({string.Join(", ", valueElements)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", resultElements)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd.Arm64/AdvSimd.Arm64_Part3_ro.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<PropertyGroup>
<DebugType>Embedded</DebugType>
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="MaxNumberPairwise.Vector128.Single.cs" />
<Compile Include="MaxNumberPairwiseScalar.Vector64.Single.cs" />
<Compile Include="MaxNumberPairwiseScalar.Vector128.Double.cs" />
<Compile Include="MaxPairwise.Vector128.Byte.cs" />
<Compile Include="MaxPairwise.Vector128.Double.cs" />
<Compile Include="MaxPairwise.Vector128.Int16.cs" />
<Compile Include="MaxPairwise.Vector128.Int32.cs" />
<Compile Include="MaxPairwise.Vector128.SByte.cs" />
<Compile Include="MaxPairwise.Vector128.Single.cs" />
<Compile Include="MaxPairwise.Vector128.UInt16.cs" />
<Compile Include="MaxPairwise.Vector128.UInt32.cs" />
<Compile Include="MaxPairwiseScalar.Vector64.Single.cs" />
<Compile Include="MaxPairwiseScalar.Vector128.Double.cs" />
<Compile Include="MaxScalar.Vector64.Double.cs" />
<Compile Include="MaxScalar.Vector64.Single.cs" />
<Compile Include="Min.Vector128.Double.cs" />
<Compile Include="MinAcross.Vector64.Byte.cs" />
<Compile Include="MinAcross.Vector64.Int16.cs" />
<Compile Include="MinAcross.Vector64.SByte.cs" />
<Compile Include="MinAcross.Vector64.UInt16.cs" />
<Compile Include="MinAcross.Vector128.Byte.cs" />
<Compile Include="MinAcross.Vector128.Int16.cs" />
<Compile Include="MinAcross.Vector128.Int32.cs" />
<Compile Include="MinAcross.Vector128.SByte.cs" />
<Compile Include="MinAcross.Vector128.Single.cs" />
<Compile Include="MinAcross.Vector128.UInt16.cs" />
<Compile Include="MinAcross.Vector128.UInt32.cs" />
<Compile Include="MinNumber.Vector128.Double.cs" />
<Compile Include="MinNumberAcross.Vector128.Single.cs" />
<Compile Include="MinNumberPairwise.Vector64.Single.cs" />
<Compile Include="MinNumberPairwise.Vector128.Double.cs" />
<Compile Include="MinNumberPairwise.Vector128.Single.cs" />
<Compile Include="MinNumberPairwiseScalar.Vector64.Single.cs" />
<Compile Include="MinNumberPairwiseScalar.Vector128.Double.cs" />
<Compile Include="MinPairwise.Vector128.Byte.cs" />
<Compile Include="MinPairwise.Vector128.Double.cs" />
<Compile Include="MinPairwise.Vector128.Int16.cs" />
<Compile Include="MinPairwise.Vector128.Int32.cs" />
<Compile Include="MinPairwise.Vector128.SByte.cs" />
<Compile Include="MinPairwise.Vector128.Single.cs" />
<Compile Include="MinPairwise.Vector128.UInt16.cs" />
<Compile Include="MinPairwise.Vector128.UInt32.cs" />
<Compile Include="MinPairwiseScalar.Vector64.Single.cs" />
<Compile Include="MinPairwiseScalar.Vector128.Double.cs" />
<Compile Include="MinScalar.Vector64.Double.cs" />
<Compile Include="MinScalar.Vector64.Single.cs" />
<Compile Include="Multiply.Vector128.Double.cs" />
<Compile Include="MultiplyByScalar.Vector128.Double.cs" />
<Compile Include="MultiplyBySelectedScalar.Vector128.Double.Vector128.Double.1.cs" />
<Compile Include="MultiplyDoublingSaturateHighScalar.Vector64.Int16.cs" />
<Compile Include="MultiplyDoublingSaturateHighScalar.Vector64.Int32.cs" />
<Compile Include="MultiplyDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int16.Vector64.Int16.3.cs" />
<Compile Include="MultiplyDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int16.Vector128.Int16.7.cs" />
<Compile Include="MultiplyDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyDoublingWideningAndAddSaturateScalar.Vector64.Int16.cs" />
<Compile Include="MultiplyDoublingWideningAndAddSaturateScalar.Vector64.Int32.cs" />
<Compile Include="MultiplyDoublingWideningAndSubtractSaturateScalar.Vector64.Int16.cs" />
<Compile Include="MultiplyDoublingWideningAndSubtractSaturateScalar.Vector64.Int32.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalar.Vector64.Int16.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalar.Vector64.Int32.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalarBySelectedScalar.Vector64.Int16.Vector64.Int16.3.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalarBySelectedScalar.Vector64.Int16.Vector128.Int16.7.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalarBySelectedScalar.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalarBySelectedScalar.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate.Vector64.Int16.Vector64.Int16.3.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate.Vector64.Int16.Vector128.Int16.7.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate.Vector64.Int16.Vector64.Int16.3.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate.Vector64.Int16.Vector128.Int16.7.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyExtended.Vector64.Single.cs" />
<Compile Include="MultiplyExtended.Vector128.Double.cs" />
<Compile Include="MultiplyExtended.Vector128.Single.cs" />
<Compile Include="MultiplyExtendedByScalar.Vector128.Double.cs" />
<Compile Include="MultiplyExtendedBySelectedScalar.Vector128.Double.Vector128.Double.1.cs" />
<Compile Include="MultiplyExtendedScalar.Vector64.Double.cs" />
<Compile Include="MultiplyExtendedScalar.Vector64.Single.cs" />
<Compile Include="MultiplyExtendedScalarBySelectedScalar.Vector64.Double.Vector128.Double.1.cs" />
<Compile Include="MultiplyExtendedScalarBySelectedScalar.Vector64.Single.Vector64.Single.1.cs" />
<Compile Include="MultiplyExtendedScalarBySelectedScalar.Vector64.Single.Vector128.Single.3.cs" />
<Compile Include="MultiplyRoundedDoublingSaturateHighScalar.Vector64.Int16.cs" />
<Compile Include="MultiplyRoundedDoublingSaturateHighScalar.Vector64.Int32.cs" />
<Compile Include="MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int16.Vector64.Int16.3.cs" />
<Compile Include="MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int16.Vector128.Int16.7.cs" />
<Compile Include="MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyScalarBySelectedScalar.Vector64.Double.Vector128.Double.1.cs" />
<Compile Include="Negate.Vector128.Double.cs" />
<Compile Include="Negate.Vector128.Int64.cs" />
<Compile Include="NegateSaturate.Vector128.Int64.cs" />
<Compile Include="NegateSaturateScalar.Vector64.Int16.cs" />
<Compile Include="NegateSaturateScalar.Vector64.Int32.cs" />
<Compile Include="NegateSaturateScalar.Vector64.Int64.cs" />
<Compile Include="NegateSaturateScalar.Vector64.SByte.cs" />
<Compile Include="NegateScalar.Vector64.Int64.cs" />
<Compile Include="ReciprocalEstimate.Vector128.Double.cs" />
<Compile Include="ReciprocalEstimateScalar.Vector64.Double.cs" />
<Compile Include="Program.AdvSimd.Arm64_Part3.cs" />
<Compile Include="..\Shared\Helpers.cs" />
<Compile Include="..\Shared\Program.cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<PropertyGroup>
<DebugType>Embedded</DebugType>
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="MaxNumberPairwise.Vector128.Single.cs" />
<Compile Include="MaxNumberPairwiseScalar.Vector64.Single.cs" />
<Compile Include="MaxNumberPairwiseScalar.Vector128.Double.cs" />
<Compile Include="MaxPairwise.Vector128.Byte.cs" />
<Compile Include="MaxPairwise.Vector128.Double.cs" />
<Compile Include="MaxPairwise.Vector128.Int16.cs" />
<Compile Include="MaxPairwise.Vector128.Int32.cs" />
<Compile Include="MaxPairwise.Vector128.SByte.cs" />
<Compile Include="MaxPairwise.Vector128.Single.cs" />
<Compile Include="MaxPairwise.Vector128.UInt16.cs" />
<Compile Include="MaxPairwise.Vector128.UInt32.cs" />
<Compile Include="MaxPairwiseScalar.Vector64.Single.cs" />
<Compile Include="MaxPairwiseScalar.Vector128.Double.cs" />
<Compile Include="MaxScalar.Vector64.Double.cs" />
<Compile Include="MaxScalar.Vector64.Single.cs" />
<Compile Include="Min.Vector128.Double.cs" />
<Compile Include="MinAcross.Vector64.Byte.cs" />
<Compile Include="MinAcross.Vector64.Int16.cs" />
<Compile Include="MinAcross.Vector64.SByte.cs" />
<Compile Include="MinAcross.Vector64.UInt16.cs" />
<Compile Include="MinAcross.Vector128.Byte.cs" />
<Compile Include="MinAcross.Vector128.Int16.cs" />
<Compile Include="MinAcross.Vector128.Int32.cs" />
<Compile Include="MinAcross.Vector128.SByte.cs" />
<Compile Include="MinAcross.Vector128.Single.cs" />
<Compile Include="MinAcross.Vector128.UInt16.cs" />
<Compile Include="MinAcross.Vector128.UInt32.cs" />
<Compile Include="MinNumber.Vector128.Double.cs" />
<Compile Include="MinNumberAcross.Vector128.Single.cs" />
<Compile Include="MinNumberPairwise.Vector64.Single.cs" />
<Compile Include="MinNumberPairwise.Vector128.Double.cs" />
<Compile Include="MinNumberPairwise.Vector128.Single.cs" />
<Compile Include="MinNumberPairwiseScalar.Vector64.Single.cs" />
<Compile Include="MinNumberPairwiseScalar.Vector128.Double.cs" />
<Compile Include="MinPairwise.Vector128.Byte.cs" />
<Compile Include="MinPairwise.Vector128.Double.cs" />
<Compile Include="MinPairwise.Vector128.Int16.cs" />
<Compile Include="MinPairwise.Vector128.Int32.cs" />
<Compile Include="MinPairwise.Vector128.SByte.cs" />
<Compile Include="MinPairwise.Vector128.Single.cs" />
<Compile Include="MinPairwise.Vector128.UInt16.cs" />
<Compile Include="MinPairwise.Vector128.UInt32.cs" />
<Compile Include="MinPairwiseScalar.Vector64.Single.cs" />
<Compile Include="MinPairwiseScalar.Vector128.Double.cs" />
<Compile Include="MinScalar.Vector64.Double.cs" />
<Compile Include="MinScalar.Vector64.Single.cs" />
<Compile Include="Multiply.Vector128.Double.cs" />
<Compile Include="MultiplyByScalar.Vector128.Double.cs" />
<Compile Include="MultiplyBySelectedScalar.Vector128.Double.Vector128.Double.1.cs" />
<Compile Include="MultiplyDoublingSaturateHighScalar.Vector64.Int16.cs" />
<Compile Include="MultiplyDoublingSaturateHighScalar.Vector64.Int32.cs" />
<Compile Include="MultiplyDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int16.Vector64.Int16.3.cs" />
<Compile Include="MultiplyDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int16.Vector128.Int16.7.cs" />
<Compile Include="MultiplyDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyDoublingWideningAndAddSaturateScalar.Vector64.Int16.cs" />
<Compile Include="MultiplyDoublingWideningAndAddSaturateScalar.Vector64.Int32.cs" />
<Compile Include="MultiplyDoublingWideningAndSubtractSaturateScalar.Vector64.Int16.cs" />
<Compile Include="MultiplyDoublingWideningAndSubtractSaturateScalar.Vector64.Int32.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalar.Vector64.Int16.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalar.Vector64.Int32.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalarBySelectedScalar.Vector64.Int16.Vector64.Int16.3.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalarBySelectedScalar.Vector64.Int16.Vector128.Int16.7.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalarBySelectedScalar.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyDoublingWideningSaturateScalarBySelectedScalar.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate.Vector64.Int16.Vector64.Int16.3.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate.Vector64.Int16.Vector128.Int16.7.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate.Vector64.Int16.Vector64.Int16.3.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate.Vector64.Int16.Vector128.Int16.7.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyExtended.Vector64.Single.cs" />
<Compile Include="MultiplyExtended.Vector128.Double.cs" />
<Compile Include="MultiplyExtended.Vector128.Single.cs" />
<Compile Include="MultiplyExtendedByScalar.Vector128.Double.cs" />
<Compile Include="MultiplyExtendedBySelectedScalar.Vector128.Double.Vector128.Double.1.cs" />
<Compile Include="MultiplyExtendedScalar.Vector64.Double.cs" />
<Compile Include="MultiplyExtendedScalar.Vector64.Single.cs" />
<Compile Include="MultiplyExtendedScalarBySelectedScalar.Vector64.Double.Vector128.Double.1.cs" />
<Compile Include="MultiplyExtendedScalarBySelectedScalar.Vector64.Single.Vector64.Single.1.cs" />
<Compile Include="MultiplyExtendedScalarBySelectedScalar.Vector64.Single.Vector128.Single.3.cs" />
<Compile Include="MultiplyRoundedDoublingSaturateHighScalar.Vector64.Int16.cs" />
<Compile Include="MultiplyRoundedDoublingSaturateHighScalar.Vector64.Int32.cs" />
<Compile Include="MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int16.Vector64.Int16.3.cs" />
<Compile Include="MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int16.Vector128.Int16.7.cs" />
<Compile Include="MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyScalarBySelectedScalar.Vector64.Double.Vector128.Double.1.cs" />
<Compile Include="Negate.Vector128.Double.cs" />
<Compile Include="Negate.Vector128.Int64.cs" />
<Compile Include="NegateSaturate.Vector128.Int64.cs" />
<Compile Include="NegateSaturateScalar.Vector64.Int16.cs" />
<Compile Include="NegateSaturateScalar.Vector64.Int32.cs" />
<Compile Include="NegateSaturateScalar.Vector64.Int64.cs" />
<Compile Include="NegateSaturateScalar.Vector64.SByte.cs" />
<Compile Include="NegateScalar.Vector64.Int64.cs" />
<Compile Include="ReciprocalEstimate.Vector128.Double.cs" />
<Compile Include="ReciprocalEstimateScalar.Vector64.Double.cs" />
<Compile Include="Program.AdvSimd.Arm64_Part3.cs" />
<Compile Include="..\Shared\Helpers.cs" />
<Compile Include="..\Shared\Program.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Private.CoreLib/src/System/Text/EncodingData.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// THIS IS AUTOGENERATED FILE CREATED BY
// https://github.com/dotnet/buildtools/blob/6736870b84e06b75e7df32bb84d442db1b2afa10/src/Microsoft.DotNet.Build.Tasks/PackageFiles/encoding.targets
namespace System.Text
{
internal static partial class EncodingTable
{
//
// s_encodingNames is the concatenation of all supported IANA names for each codepage.
// This is done rather than using a large readonly array of strings to avoid
// generating a large amount of code in the static constructor.
// Using indices from s_encodingNamesIndices, we binary search this string when mapping
// an encoding name to a codepage. Note that these names are all lowercase and are
// sorted alphabetically.
//
private const string s_encodingNames =
"ansi_x3.4-1968" + // 20127
"ansi_x3.4-1986" + // 20127
"ascii" + // 20127
"cp367" + // 20127
"cp819" + // 28591
"csascii" + // 20127
"csisolatin1" + // 28591
"csunicode11utf7" + // 65000
"ibm367" + // 20127
"ibm819" + // 28591
"iso-10646-ucs-2" + // 1200
"iso-8859-1" + // 28591
"iso-ir-100" + // 28591
"iso-ir-6" + // 20127
"iso646-us" + // 20127
"iso8859-1" + // 28591
"iso_646.irv:1991" + // 20127
"iso_8859-1" + // 28591
"iso_8859-1:1987" + // 28591
"l1" + // 28591
"latin1" + // 28591
"ucs-2" + // 1200
"unicode" + // 1200
"unicode-1-1-utf-7" + // 65000
"unicode-1-1-utf-8" + // 65001
"unicode-2-0-utf-7" + // 65000
"unicode-2-0-utf-8" + // 65001
"unicodefffe" + // 1201
"us" + // 20127
"us-ascii" + // 20127
"utf-16" + // 1200
"utf-16be" + // 1201
"utf-16le" + // 1200
"utf-32" + // 12000
"utf-32be" + // 12001
"utf-32le" + // 12000
"utf-7" + // 65000
"utf-8" + // 65001
"x-unicode-1-1-utf-7" + // 65000
"x-unicode-1-1-utf-8" + // 65001
"x-unicode-2-0-utf-7" + // 65000
"x-unicode-2-0-utf-8"; // 65001
//
// s_encodingNameIndices contains the start index of every encoding name in the string
// s_encodingNames. We infer the length of each string by looking at the start index
// of the next string.
//
private static readonly int[] s_encodingNameIndices = new int[]
{
0, // ansi_x3.4-1968 (20127)
14, // ansi_x3.4-1986 (20127)
28, // ascii (20127)
33, // cp367 (20127)
38, // cp819 (28591)
43, // csascii (20127)
50, // csisolatin1 (28591)
61, // csunicode11utf7 (65000)
76, // ibm367 (20127)
82, // ibm819 (28591)
88, // iso-10646-ucs-2 (1200)
103, // iso-8859-1 (28591)
113, // iso-ir-100 (28591)
123, // iso-ir-6 (20127)
131, // iso646-us (20127)
140, // iso8859-1 (28591)
149, // iso_646.irv:1991 (20127)
165, // iso_8859-1 (28591)
175, // iso_8859-1:1987 (28591)
190, // l1 (28591)
192, // latin1 (28591)
198, // ucs-2 (1200)
203, // unicode (1200)
210, // unicode-1-1-utf-7 (65000)
227, // unicode-1-1-utf-8 (65001)
244, // unicode-2-0-utf-7 (65000)
261, // unicode-2-0-utf-8 (65001)
278, // unicodefffe (1201)
289, // us (20127)
291, // us-ascii (20127)
299, // utf-16 (1200)
305, // utf-16be (1201)
313, // utf-16le (1200)
321, // utf-32 (12000)
327, // utf-32be (12001)
335, // utf-32le (12000)
343, // utf-7 (65000)
348, // utf-8 (65001)
353, // x-unicode-1-1-utf-7 (65000)
372, // x-unicode-1-1-utf-8 (65001)
391, // x-unicode-2-0-utf-7 (65000)
410, // x-unicode-2-0-utf-8 (65001)
429
};
//
// s_codePagesByName contains the list of supported codepages which match the encoding
// names listed in s_encodingNames. The way mapping works is we binary search
// s_encodingNames using s_encodingNamesIndices until we find a match for a given name.
// The index of the entry in s_encodingNamesIndices will be the index of codepage in
// s_codePagesByName.
//
private static readonly ushort[] s_codePagesByName = new ushort[]
{
20127, // ansi_x3.4-1968
20127, // ansi_x3.4-1986
20127, // ascii
20127, // cp367
28591, // cp819
20127, // csascii
28591, // csisolatin1
65000, // csunicode11utf7
20127, // ibm367
28591, // ibm819
1200, // iso-10646-ucs-2
28591, // iso-8859-1
28591, // iso-ir-100
20127, // iso-ir-6
20127, // iso646-us
28591, // iso8859-1
20127, // iso_646.irv:1991
28591, // iso_8859-1
28591, // iso_8859-1:1987
28591, // l1
28591, // latin1
1200, // ucs-2
1200, // unicode
65000, // unicode-1-1-utf-7
65001, // unicode-1-1-utf-8
65000, // unicode-2-0-utf-7
65001, // unicode-2-0-utf-8
1201, // unicodefffe
20127, // us
20127, // us-ascii
1200, // utf-16
1201, // utf-16be
1200, // utf-16le
12000, // utf-32
12001, // utf-32be
12000, // utf-32le
65000, // utf-7
65001, // utf-8
65000, // x-unicode-1-1-utf-7
65001, // x-unicode-1-1-utf-8
65000, // x-unicode-2-0-utf-7
65001 // x-unicode-2-0-utf-8
};
//
// When retrieving the value for System.Text.Encoding.WebName or
// System.Text.Encoding.EncodingName given System.Text.Encoding.CodePage,
// we perform a linear search on s_mappedCodePages to find the index of the
// given codepage. This is used to index WebNameIndices to get the start
// index of the web name in the string WebNames, and to index
// s_englishNameIndices to get the start of the English name in
// s_englishNames. In addition, this arrays indices correspond to the indices
// into s_uiFamilyCodePages and s_flags.
//
private static readonly ushort[] s_mappedCodePages = new ushort[]
{
1200, // utf-16
1201, // utf-16be
12000, // utf-32
12001, // utf-32be
20127, // us-ascii
28591, // iso-8859-1
65000, // utf-7
65001 // utf-8
};
//
// s_uiFamilyCodePages is indexed by the corresponding index in s_mappedCodePages.
//
private static readonly int[] s_uiFamilyCodePages = new int[]
{
1200,
1200,
1200,
1200,
1252,
1252,
1200,
1200
};
//
// s_webNames is a concatenation of the default encoding names
// for each code page. It is used in retrieving the value for
// System.Text.Encoding.WebName given System.Text.Encoding.CodePage.
// This is done rather than using a large readonly array of strings to avoid
// generating a large amount of code in the static constructor.
//
private const string s_webNames =
"utf-16" + // 1200
"utf-16BE" + // 1201
"utf-32" + // 12000
"utf-32BE" + // 12001
"us-ascii" + // 20127
"iso-8859-1" + // 28591
"utf-7" + // 65000
"utf-8"; // 65001
//
// s_webNameIndices contains the start index of each code page's default
// web name in the string s_webNames. It is indexed by an index into
// s_mappedCodePages.
//
private static readonly int[] s_webNameIndices = new int[]
{
0, // utf-16 (1200)
6, // utf-16be (1201)
14, // utf-32 (12000)
20, // utf-32be (12001)
28, // us-ascii (20127)
36, // iso-8859-1 (28591)
46, // utf-7 (65000)
51, // utf-8 (65001)
56
};
//
// s_englishNames is the concatenation of the English names for each codepage.
// It is used in retrieving the value for System.Text.Encoding.EncodingName
// given System.Text.Encoding.CodePage.
// This is done rather than using a large readonly array of strings to avoid
// generating a large amount of code in the static constructor.
//
private const string s_englishNames =
"Unicode" + // 1200
"Unicode (Big-Endian)" + // 1201
"Unicode (UTF-32)" + // 12000
"Unicode (UTF-32 Big-Endian)" + // 12001
"US-ASCII" + // 20127
"Western European (ISO)" + // 28591
"Unicode (UTF-7)" + // 65000
"Unicode (UTF-8)"; // 65001
//
// s_englishNameIndices contains the start index of each code page's English
// name in the string s_englishNames. It is indexed by an index into
// s_mappedCodePages.
//
private static readonly int[] s_englishNameIndices = new int[]
{
0, // Unicode (1200)
7, // Unicode (Big-Endian) (1201)
27, // Unicode (UTF-32) (12000)
43, // Unicode (UTF-32 Big-Endian) (12001)
70, // US-ASCII (20127)
78, // Western European (ISO) (28591)
100, // Unicode (UTF-7) (65000)
115, // Unicode (UTF-8) (65001)
130
};
// redeclaring these constants here for readability below
private const uint MIMECONTF_MAILNEWS = Encoding.MIMECONTF_MAILNEWS;
private const uint MIMECONTF_BROWSER = Encoding.MIMECONTF_BROWSER;
private const uint MIMECONTF_SAVABLE_MAILNEWS = Encoding.MIMECONTF_SAVABLE_MAILNEWS;
private const uint MIMECONTF_SAVABLE_BROWSER = Encoding.MIMECONTF_SAVABLE_BROWSER;
// s_flags is indexed by the corresponding index in s_mappedCodePages.
private static readonly uint[] s_flags = new uint[]
{
MIMECONTF_SAVABLE_BROWSER,
0,
0,
0,
MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS,
MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER,
MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS,
MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER
};
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// THIS IS AUTOGENERATED FILE CREATED BY
// https://github.com/dotnet/buildtools/blob/6736870b84e06b75e7df32bb84d442db1b2afa10/src/Microsoft.DotNet.Build.Tasks/PackageFiles/encoding.targets
namespace System.Text
{
internal static partial class EncodingTable
{
//
// s_encodingNames is the concatenation of all supported IANA names for each codepage.
// This is done rather than using a large readonly array of strings to avoid
// generating a large amount of code in the static constructor.
// Using indices from s_encodingNamesIndices, we binary search this string when mapping
// an encoding name to a codepage. Note that these names are all lowercase and are
// sorted alphabetically.
//
private const string s_encodingNames =
"ansi_x3.4-1968" + // 20127
"ansi_x3.4-1986" + // 20127
"ascii" + // 20127
"cp367" + // 20127
"cp819" + // 28591
"csascii" + // 20127
"csisolatin1" + // 28591
"csunicode11utf7" + // 65000
"ibm367" + // 20127
"ibm819" + // 28591
"iso-10646-ucs-2" + // 1200
"iso-8859-1" + // 28591
"iso-ir-100" + // 28591
"iso-ir-6" + // 20127
"iso646-us" + // 20127
"iso8859-1" + // 28591
"iso_646.irv:1991" + // 20127
"iso_8859-1" + // 28591
"iso_8859-1:1987" + // 28591
"l1" + // 28591
"latin1" + // 28591
"ucs-2" + // 1200
"unicode" + // 1200
"unicode-1-1-utf-7" + // 65000
"unicode-1-1-utf-8" + // 65001
"unicode-2-0-utf-7" + // 65000
"unicode-2-0-utf-8" + // 65001
"unicodefffe" + // 1201
"us" + // 20127
"us-ascii" + // 20127
"utf-16" + // 1200
"utf-16be" + // 1201
"utf-16le" + // 1200
"utf-32" + // 12000
"utf-32be" + // 12001
"utf-32le" + // 12000
"utf-7" + // 65000
"utf-8" + // 65001
"x-unicode-1-1-utf-7" + // 65000
"x-unicode-1-1-utf-8" + // 65001
"x-unicode-2-0-utf-7" + // 65000
"x-unicode-2-0-utf-8"; // 65001
//
// s_encodingNameIndices contains the start index of every encoding name in the string
// s_encodingNames. We infer the length of each string by looking at the start index
// of the next string.
//
private static readonly int[] s_encodingNameIndices = new int[]
{
0, // ansi_x3.4-1968 (20127)
14, // ansi_x3.4-1986 (20127)
28, // ascii (20127)
33, // cp367 (20127)
38, // cp819 (28591)
43, // csascii (20127)
50, // csisolatin1 (28591)
61, // csunicode11utf7 (65000)
76, // ibm367 (20127)
82, // ibm819 (28591)
88, // iso-10646-ucs-2 (1200)
103, // iso-8859-1 (28591)
113, // iso-ir-100 (28591)
123, // iso-ir-6 (20127)
131, // iso646-us (20127)
140, // iso8859-1 (28591)
149, // iso_646.irv:1991 (20127)
165, // iso_8859-1 (28591)
175, // iso_8859-1:1987 (28591)
190, // l1 (28591)
192, // latin1 (28591)
198, // ucs-2 (1200)
203, // unicode (1200)
210, // unicode-1-1-utf-7 (65000)
227, // unicode-1-1-utf-8 (65001)
244, // unicode-2-0-utf-7 (65000)
261, // unicode-2-0-utf-8 (65001)
278, // unicodefffe (1201)
289, // us (20127)
291, // us-ascii (20127)
299, // utf-16 (1200)
305, // utf-16be (1201)
313, // utf-16le (1200)
321, // utf-32 (12000)
327, // utf-32be (12001)
335, // utf-32le (12000)
343, // utf-7 (65000)
348, // utf-8 (65001)
353, // x-unicode-1-1-utf-7 (65000)
372, // x-unicode-1-1-utf-8 (65001)
391, // x-unicode-2-0-utf-7 (65000)
410, // x-unicode-2-0-utf-8 (65001)
429
};
//
// s_codePagesByName contains the list of supported codepages which match the encoding
// names listed in s_encodingNames. The way mapping works is we binary search
// s_encodingNames using s_encodingNamesIndices until we find a match for a given name.
// The index of the entry in s_encodingNamesIndices will be the index of codepage in
// s_codePagesByName.
//
private static readonly ushort[] s_codePagesByName = new ushort[]
{
20127, // ansi_x3.4-1968
20127, // ansi_x3.4-1986
20127, // ascii
20127, // cp367
28591, // cp819
20127, // csascii
28591, // csisolatin1
65000, // csunicode11utf7
20127, // ibm367
28591, // ibm819
1200, // iso-10646-ucs-2
28591, // iso-8859-1
28591, // iso-ir-100
20127, // iso-ir-6
20127, // iso646-us
28591, // iso8859-1
20127, // iso_646.irv:1991
28591, // iso_8859-1
28591, // iso_8859-1:1987
28591, // l1
28591, // latin1
1200, // ucs-2
1200, // unicode
65000, // unicode-1-1-utf-7
65001, // unicode-1-1-utf-8
65000, // unicode-2-0-utf-7
65001, // unicode-2-0-utf-8
1201, // unicodefffe
20127, // us
20127, // us-ascii
1200, // utf-16
1201, // utf-16be
1200, // utf-16le
12000, // utf-32
12001, // utf-32be
12000, // utf-32le
65000, // utf-7
65001, // utf-8
65000, // x-unicode-1-1-utf-7
65001, // x-unicode-1-1-utf-8
65000, // x-unicode-2-0-utf-7
65001 // x-unicode-2-0-utf-8
};
//
// When retrieving the value for System.Text.Encoding.WebName or
// System.Text.Encoding.EncodingName given System.Text.Encoding.CodePage,
// we perform a linear search on s_mappedCodePages to find the index of the
// given codepage. This is used to index WebNameIndices to get the start
// index of the web name in the string WebNames, and to index
// s_englishNameIndices to get the start of the English name in
// s_englishNames. In addition, this arrays indices correspond to the indices
// into s_uiFamilyCodePages and s_flags.
//
private static readonly ushort[] s_mappedCodePages = new ushort[]
{
1200, // utf-16
1201, // utf-16be
12000, // utf-32
12001, // utf-32be
20127, // us-ascii
28591, // iso-8859-1
65000, // utf-7
65001 // utf-8
};
//
// s_uiFamilyCodePages is indexed by the corresponding index in s_mappedCodePages.
//
private static readonly int[] s_uiFamilyCodePages = new int[]
{
1200,
1200,
1200,
1200,
1252,
1252,
1200,
1200
};
//
// s_webNames is a concatenation of the default encoding names
// for each code page. It is used in retrieving the value for
// System.Text.Encoding.WebName given System.Text.Encoding.CodePage.
// This is done rather than using a large readonly array of strings to avoid
// generating a large amount of code in the static constructor.
//
private const string s_webNames =
"utf-16" + // 1200
"utf-16BE" + // 1201
"utf-32" + // 12000
"utf-32BE" + // 12001
"us-ascii" + // 20127
"iso-8859-1" + // 28591
"utf-7" + // 65000
"utf-8"; // 65001
//
// s_webNameIndices contains the start index of each code page's default
// web name in the string s_webNames. It is indexed by an index into
// s_mappedCodePages.
//
private static readonly int[] s_webNameIndices = new int[]
{
0, // utf-16 (1200)
6, // utf-16be (1201)
14, // utf-32 (12000)
20, // utf-32be (12001)
28, // us-ascii (20127)
36, // iso-8859-1 (28591)
46, // utf-7 (65000)
51, // utf-8 (65001)
56
};
//
// s_englishNames is the concatenation of the English names for each codepage.
// It is used in retrieving the value for System.Text.Encoding.EncodingName
// given System.Text.Encoding.CodePage.
// This is done rather than using a large readonly array of strings to avoid
// generating a large amount of code in the static constructor.
//
private const string s_englishNames =
"Unicode" + // 1200
"Unicode (Big-Endian)" + // 1201
"Unicode (UTF-32)" + // 12000
"Unicode (UTF-32 Big-Endian)" + // 12001
"US-ASCII" + // 20127
"Western European (ISO)" + // 28591
"Unicode (UTF-7)" + // 65000
"Unicode (UTF-8)"; // 65001
//
// s_englishNameIndices contains the start index of each code page's English
// name in the string s_englishNames. It is indexed by an index into
// s_mappedCodePages.
//
private static readonly int[] s_englishNameIndices = new int[]
{
0, // Unicode (1200)
7, // Unicode (Big-Endian) (1201)
27, // Unicode (UTF-32) (12000)
43, // Unicode (UTF-32 Big-Endian) (12001)
70, // US-ASCII (20127)
78, // Western European (ISO) (28591)
100, // Unicode (UTF-7) (65000)
115, // Unicode (UTF-8) (65001)
130
};
// redeclaring these constants here for readability below
private const uint MIMECONTF_MAILNEWS = Encoding.MIMECONTF_MAILNEWS;
private const uint MIMECONTF_BROWSER = Encoding.MIMECONTF_BROWSER;
private const uint MIMECONTF_SAVABLE_MAILNEWS = Encoding.MIMECONTF_SAVABLE_MAILNEWS;
private const uint MIMECONTF_SAVABLE_BROWSER = Encoding.MIMECONTF_SAVABLE_BROWSER;
// s_flags is indexed by the corresponding index in s_mappedCodePages.
private static readonly uint[] s_flags = new uint[]
{
MIMECONTF_SAVABLE_BROWSER,
0,
0,
0,
MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS,
MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER,
MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS,
MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER
};
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/Regression/JitBlue/GitHub_18332/GitHub_18332.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Collections.Generic;
internal class Foo : IDisposable
{
public void Dispose()
{
}
}
class GitHub_18332
{
// In Aargh there is a finally with two distinct exit paths.
// Finally cloning may choose the non-fall through ("wibble") exit
// path to clone, and then will try to incorrectly arrange for
// that path to become the fall through.
public static string Aargh()
{
using (var foo = new Foo())
{
foreach (var i in new List<int>())
{
try
{
Console.WriteLine("here");
}
catch (Exception)
{
return "wibble";
}
}
foreach (var i in new List<int>())
{
}
}
return "wobble";
}
public static int Main(string[] args)
{
string expected = "wobble";
string actual = Aargh();
if (actual != expected)
{
Console.WriteLine($"FAIL: Aargh() returns '{actual}' expected '{expected}'");
return 0;
}
return 100;
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Collections.Generic;
internal class Foo : IDisposable
{
public void Dispose()
{
}
}
class GitHub_18332
{
// In Aargh there is a finally with two distinct exit paths.
// Finally cloning may choose the non-fall through ("wibble") exit
// path to clone, and then will try to incorrectly arrange for
// that path to become the fall through.
public static string Aargh()
{
using (var foo = new Foo())
{
foreach (var i in new List<int>())
{
try
{
Console.WriteLine("here");
}
catch (Exception)
{
return "wibble";
}
}
foreach (var i in new List<int>())
{
}
}
return "wobble";
}
public static int Main(string[] args)
{
string expected = "wobble";
string actual = Aargh();
if (actual != expected)
{
Console.WriteLine($"FAIL: Aargh() returns '{actual}' expected '{expected}'");
return 0;
}
return 100;
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/Directed/CheckedCtor/Generic_Test_CSharp_Base_6.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
//
// This test represents a case where csc.exe puts a base/peer ctor callsite outside of the
// first block of the derived ctor.
//
// Specifically covers: "Use of 'new T()' in a generic base ctor argument expression"
//
using System;
using System.Runtime.CompilerServices;
namespace Test
{
static class App
{
static int Main()
{
new DerivedClass<Reftype>();
new DerivedClass<Valuetype>();
return 100;
}
}
public class BaseClass<T>
{
[MethodImpl(MethodImplOptions.NoInlining)]
public BaseClass(T arg) { Console.Write("BaseClass::.ctor -- `{0}'\r\n", arg.ToString()); return; }
}
public class DerivedClass<T> : BaseClass<T> where T : new()
{
[MethodImpl(MethodImplOptions.NoInlining)]
public DerivedClass() : base(new T()) { }
}
public class Reftype
{
public override string ToString() { return "Reftype instance"; }
}
public struct Valuetype
{
public override string ToString() { return "Valuetype instance"; }
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
//
// This test represents a case where csc.exe puts a base/peer ctor callsite outside of the
// first block of the derived ctor.
//
// Specifically covers: "Use of 'new T()' in a generic base ctor argument expression"
//
using System;
using System.Runtime.CompilerServices;
namespace Test
{
static class App
{
static int Main()
{
new DerivedClass<Reftype>();
new DerivedClass<Valuetype>();
return 100;
}
}
public class BaseClass<T>
{
[MethodImpl(MethodImplOptions.NoInlining)]
public BaseClass(T arg) { Console.Write("BaseClass::.ctor -- `{0}'\r\n", arg.ToString()); return; }
}
public class DerivedClass<T> : BaseClass<T> where T : new()
{
[MethodImpl(MethodImplOptions.NoInlining)]
public DerivedClass() : base(new T()) { }
}
public class Reftype
{
public override string ToString() { return "Reftype instance"; }
}
public struct Valuetype
{
public override string ToString() { return "Valuetype instance"; }
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/Generics/Typeof/class02.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
using System;
public struct ValX0 { }
public struct ValY0 { }
public struct ValX1<T> { }
public struct ValY1<T> { }
public struct ValX2<T, U> { }
public struct ValY2<T, U> { }
public struct ValX3<T, U, V> { }
public struct ValY3<T, U, V> { }
public class RefX0 { }
public class RefY0 { }
public class RefX1<T> { }
public class RefY1<T> { }
public class RefX2<T, U> { }
public class RefY2<T, U> { }
public class RefX3<T, U, V> { }
public class RefY3<T, U, V> { }
public class Gen<T, U>
{
public T Fld1;
public U Fld2;
public Gen(T fld1, U fld2)
{
Fld1 = fld1;
Fld2 = fld2;
}
public bool InstVerify(System.Type t1, System.Type t2)
{
bool result = true;
if (!(typeof(T).Equals(t1)))
{
result = false;
Console.WriteLine("Failed to verify type of Fld1 in: " + typeof(Gen<T, U>));
}
if (!(typeof(U).Equals(t2)))
{
result = false;
Console.WriteLine("Failed to verify type of Fld2 in: " + typeof(Gen<T, U>));
}
return result;
}
}
public class Test_class02
{
public static int counter = 0;
public static bool result = true;
public static void Eval(bool exp)
{
counter++;
if (!exp)
{
result = exp;
Console.WriteLine("Test Failed at location: " + counter);
}
}
public static int Main()
{
Eval((new Gen<int, int>(new int(), new int())).InstVerify(typeof(int), typeof(int)));
Eval((new Gen<int, double>(new int(), new double())).InstVerify(typeof(int), typeof(double)));
Eval((new Gen<int, string>(new int(), "string")).InstVerify(typeof(int), typeof(string)));
Eval((new Gen<int, object>(new int(), new object())).InstVerify(typeof(int), typeof(object)));
Eval((new Gen<int, Guid>(new int(), new Guid())).InstVerify(typeof(int), typeof(Guid)));
Eval((new Gen<int, RefX1<int>>(new int(), new RefX1<int>())).InstVerify(typeof(int), typeof(RefX1<int>)));
Eval((new Gen<int, RefX1<string>>(new int(), new RefX1<string>())).InstVerify(typeof(int), typeof(RefX1<string>)));
Eval((new Gen<int, RefX1<int[][, , ,][]>>(new int(), new RefX1<int[][, , ,][]>())).InstVerify(typeof(int), typeof(RefX1<int[][, , ,][]>)));
Eval((new Gen<int, ValX1<int>>(new int(), new ValX1<int>())).InstVerify(typeof(int), typeof(ValX1<int>)));
Eval((new Gen<int, ValX1<string>>(new int(), new ValX1<string>())).InstVerify(typeof(int), typeof(ValX1<string>)));
Eval((new Gen<int, ValX1<int[][, , ,][]>>(new int(), new ValX1<int[][, , ,][]>())).InstVerify(typeof(int), typeof(ValX1<int[][, , ,][]>)));
Eval((new Gen<double, int>(new double(), new int())).InstVerify(typeof(double), typeof(int)));
Eval((new Gen<double, double>(new double(), new double())).InstVerify(typeof(double), typeof(double)));
Eval((new Gen<double, string>(new double(), "string")).InstVerify(typeof(double), typeof(string)));
Eval((new Gen<double, object>(new double(), new object())).InstVerify(typeof(double), typeof(object)));
Eval((new Gen<double, Guid>(new double(), new Guid())).InstVerify(typeof(double), typeof(Guid)));
Eval((new Gen<double, RefX1<double>>(new double(), new RefX1<double>())).InstVerify(typeof(double), typeof(RefX1<double>)));
Eval((new Gen<double, RefX1<string>>(new double(), new RefX1<string>())).InstVerify(typeof(double), typeof(RefX1<string>)));
Eval((new Gen<double, RefX1<double[][, , ,][]>>(new double(), new RefX1<double[][, , ,][]>())).InstVerify(typeof(double), typeof(RefX1<double[][, , ,][]>)));
Eval((new Gen<double, ValX1<double>>(new double(), new ValX1<double>())).InstVerify(typeof(double), typeof(ValX1<double>)));
Eval((new Gen<double, ValX1<string>>(new double(), new ValX1<string>())).InstVerify(typeof(double), typeof(ValX1<string>)));
Eval((new Gen<double, ValX1<double[][, , ,][]>>(new double(), new ValX1<double[][, , ,][]>())).InstVerify(typeof(double), typeof(ValX1<double[][, , ,][]>)));
Eval((new Gen<string, int>("string", new int())).InstVerify(typeof(string), typeof(int)));
Eval((new Gen<string, double>("string", new double())).InstVerify(typeof(string), typeof(double)));
Eval((new Gen<string, string>("string", "string")).InstVerify(typeof(string), typeof(string)));
Eval((new Gen<string, object>("string", new object())).InstVerify(typeof(string), typeof(object)));
Eval((new Gen<string, Guid>("string", new Guid())).InstVerify(typeof(string), typeof(Guid)));
Eval((new Gen<string, RefX1<string>>("string", new RefX1<string>())).InstVerify(typeof(string), typeof(RefX1<string>)));
Eval((new Gen<string, RefX1<string>>("string", new RefX1<string>())).InstVerify(typeof(string), typeof(RefX1<string>)));
Eval((new Gen<string, RefX1<string[][, , ,][]>>("string", new RefX1<string[][, , ,][]>())).InstVerify(typeof(string), typeof(RefX1<string[][, , ,][]>)));
Eval((new Gen<string, ValX1<string>>("string", new ValX1<string>())).InstVerify(typeof(string), typeof(ValX1<string>)));
Eval((new Gen<string, ValX1<string>>("string", new ValX1<string>())).InstVerify(typeof(string), typeof(ValX1<string>)));
Eval((new Gen<string, ValX1<string[][, , ,][]>>("string", new ValX1<string[][, , ,][]>())).InstVerify(typeof(string), typeof(ValX1<string[][, , ,][]>)));
Eval((new Gen<object, int>(new object(), new int())).InstVerify(typeof(object), typeof(int)));
Eval((new Gen<object, double>(new object(), new double())).InstVerify(typeof(object), typeof(double)));
Eval((new Gen<object, string>(new object(), "string")).InstVerify(typeof(object), typeof(string)));
Eval((new Gen<object, object>(new object(), new object())).InstVerify(typeof(object), typeof(object)));
Eval((new Gen<object, Guid>(new object(), new Guid())).InstVerify(typeof(object), typeof(Guid)));
Eval((new Gen<object, RefX1<object>>(new object(), new RefX1<object>())).InstVerify(typeof(object), typeof(RefX1<object>)));
Eval((new Gen<object, RefX1<string>>(new object(), new RefX1<string>())).InstVerify(typeof(object), typeof(RefX1<string>)));
Eval((new Gen<object, RefX1<object[][, , ,][]>>(new object(), new RefX1<object[][, , ,][]>())).InstVerify(typeof(object), typeof(RefX1<object[][, , ,][]>)));
Eval((new Gen<object, ValX1<object>>(new object(), new ValX1<object>())).InstVerify(typeof(object), typeof(ValX1<object>)));
Eval((new Gen<object, ValX1<string>>(new object(), new ValX1<string>())).InstVerify(typeof(object), typeof(ValX1<string>)));
Eval((new Gen<object, ValX1<object[][, , ,][]>>(new object(), new ValX1<object[][, , ,][]>())).InstVerify(typeof(object), typeof(ValX1<object[][, , ,][]>)));
Eval((new Gen<Guid, int>(new Guid(), new int())).InstVerify(typeof(Guid), typeof(int)));
Eval((new Gen<Guid, double>(new Guid(), new double())).InstVerify(typeof(Guid), typeof(double)));
Eval((new Gen<Guid, string>(new Guid(), "string")).InstVerify(typeof(Guid), typeof(string)));
Eval((new Gen<Guid, object>(new Guid(), new object())).InstVerify(typeof(Guid), typeof(object)));
Eval((new Gen<Guid, Guid>(new Guid(), new Guid())).InstVerify(typeof(Guid), typeof(Guid)));
Eval((new Gen<Guid, RefX1<Guid>>(new Guid(), new RefX1<Guid>())).InstVerify(typeof(Guid), typeof(RefX1<Guid>)));
Eval((new Gen<Guid, RefX1<string>>(new Guid(), new RefX1<string>())).InstVerify(typeof(Guid), typeof(RefX1<string>)));
Eval((new Gen<Guid, RefX1<Guid[][, , ,][]>>(new Guid(), new RefX1<Guid[][, , ,][]>())).InstVerify(typeof(Guid), typeof(RefX1<Guid[][, , ,][]>)));
Eval((new Gen<Guid, ValX1<Guid>>(new Guid(), new ValX1<Guid>())).InstVerify(typeof(Guid), typeof(ValX1<Guid>)));
Eval((new Gen<Guid, ValX1<string>>(new Guid(), new ValX1<string>())).InstVerify(typeof(Guid), typeof(ValX1<string>)));
Eval((new Gen<Guid, ValX1<Guid[][, , ,][]>>(new Guid(), new ValX1<Guid[][, , ,][]>())).InstVerify(typeof(Guid), typeof(ValX1<Guid[][, , ,][]>)));
Eval((new Gen<RefX1<int>, int>(new RefX1<int>(), new int())).InstVerify(typeof(RefX1<int>), typeof(int)));
Eval((new Gen<RefX1<long>, double>(new RefX1<long>(), new double())).InstVerify(typeof(RefX1<long>), typeof(double)));
Eval((new Gen<RefX1<long>, string>(new RefX1<long>(), "string")).InstVerify(typeof(RefX1<long>), typeof(string)));
Eval((new Gen<RefX1<long>, object>(new RefX1<long>(), new object())).InstVerify(typeof(RefX1<long>), typeof(object)));
Eval((new Gen<RefX1<long>, Guid>(new RefX1<long>(), new Guid())).InstVerify(typeof(RefX1<long>), typeof(Guid)));
Eval((new Gen<RefX1<long>, RefX1<RefX1<long>>>(new RefX1<long>(), new RefX1<RefX1<long>>())).InstVerify(typeof(RefX1<long>), typeof(RefX1<RefX1<long>>)));
Eval((new Gen<RefX1<long>, RefX1<string>>(new RefX1<long>(), new RefX1<string>())).InstVerify(typeof(RefX1<long>), typeof(RefX1<string>)));
Eval((new Gen<RefX1<long>, RefX1<RefX1<long[][, , ,][]>>>(new RefX1<long>(), new RefX1<RefX1<long[][, , ,][]>>())).InstVerify(typeof(RefX1<long>), typeof(RefX1<RefX1<long[][, , ,][]>>)));
Eval((new Gen<RefX1<long>, ValX1<RefX1<long>>>(new RefX1<long>(), new ValX1<RefX1<long>>())).InstVerify(typeof(RefX1<long>), typeof(ValX1<RefX1<long>>)));
Eval((new Gen<RefX1<long>, ValX1<string>>(new RefX1<long>(), new ValX1<string>())).InstVerify(typeof(RefX1<long>), typeof(ValX1<string>)));
Eval((new Gen<RefX1<long>, ValX1<RefX1<long>[][, , ,][]>>(new RefX1<long>(), new ValX1<RefX1<long>[][, , ,][]>())).InstVerify(typeof(RefX1<long>), typeof(ValX1<RefX1<long>[][, , ,][]>)));
Eval((new Gen<ValX1<string>, int>(new ValX1<string>(), new int())).InstVerify(typeof(ValX1<string>), typeof(int)));
Eval((new Gen<ValX1<string>, double>(new ValX1<string>(), new double())).InstVerify(typeof(ValX1<string>), typeof(double)));
Eval((new Gen<ValX1<string>, string>(new ValX1<string>(), "string")).InstVerify(typeof(ValX1<string>), typeof(string)));
Eval((new Gen<ValX1<string>, object>(new ValX1<string>(), new object())).InstVerify(typeof(ValX1<string>), typeof(object)));
Eval((new Gen<ValX1<string>, Guid>(new ValX1<string>(), new Guid())).InstVerify(typeof(ValX1<string>), typeof(Guid)));
Eval((new Gen<ValX1<string>, RefX1<ValX1<string>>>(new ValX1<string>(), new RefX1<ValX1<string>>())).InstVerify(typeof(ValX1<string>), typeof(RefX1<ValX1<string>>)));
Eval((new Gen<ValX1<string>, RefX1<string>>(new ValX1<string>(), new RefX1<string>())).InstVerify(typeof(ValX1<string>), typeof(RefX1<string>)));
Eval((new Gen<ValX1<string>, RefX1<ValX1<string>[][, , ,][]>>(new ValX1<string>(), new RefX1<ValX1<string>[][, , ,][]>())).InstVerify(typeof(ValX1<string>), typeof(RefX1<ValX1<string>[][, , ,][]>)));
Eval((new Gen<ValX1<string>, ValX1<ValX1<string>>>(new ValX1<string>(), new ValX1<ValX1<string>>())).InstVerify(typeof(ValX1<string>), typeof(ValX1<ValX1<string>>)));
Eval((new Gen<ValX1<string>, ValX1<string>>(new ValX1<string>(), new ValX1<string>())).InstVerify(typeof(ValX1<string>), typeof(ValX1<string>)));
Eval((new Gen<ValX1<string>, ValX1<ValX1<string>[][, , ,][]>>(new ValX1<string>(), new ValX1<ValX1<string>[][, , ,][]>())).InstVerify(typeof(ValX1<string>), typeof(ValX1<ValX1<string>[][, , ,][]>)));
if (result)
{
Console.WriteLine("Test Passed");
return 100;
}
else
{
Console.WriteLine("Test Failed");
return 1;
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
using System;
public struct ValX0 { }
public struct ValY0 { }
public struct ValX1<T> { }
public struct ValY1<T> { }
public struct ValX2<T, U> { }
public struct ValY2<T, U> { }
public struct ValX3<T, U, V> { }
public struct ValY3<T, U, V> { }
public class RefX0 { }
public class RefY0 { }
public class RefX1<T> { }
public class RefY1<T> { }
public class RefX2<T, U> { }
public class RefY2<T, U> { }
public class RefX3<T, U, V> { }
public class RefY3<T, U, V> { }
public class Gen<T, U>
{
public T Fld1;
public U Fld2;
public Gen(T fld1, U fld2)
{
Fld1 = fld1;
Fld2 = fld2;
}
public bool InstVerify(System.Type t1, System.Type t2)
{
bool result = true;
if (!(typeof(T).Equals(t1)))
{
result = false;
Console.WriteLine("Failed to verify type of Fld1 in: " + typeof(Gen<T, U>));
}
if (!(typeof(U).Equals(t2)))
{
result = false;
Console.WriteLine("Failed to verify type of Fld2 in: " + typeof(Gen<T, U>));
}
return result;
}
}
public class Test_class02
{
public static int counter = 0;
public static bool result = true;
public static void Eval(bool exp)
{
counter++;
if (!exp)
{
result = exp;
Console.WriteLine("Test Failed at location: " + counter);
}
}
public static int Main()
{
Eval((new Gen<int, int>(new int(), new int())).InstVerify(typeof(int), typeof(int)));
Eval((new Gen<int, double>(new int(), new double())).InstVerify(typeof(int), typeof(double)));
Eval((new Gen<int, string>(new int(), "string")).InstVerify(typeof(int), typeof(string)));
Eval((new Gen<int, object>(new int(), new object())).InstVerify(typeof(int), typeof(object)));
Eval((new Gen<int, Guid>(new int(), new Guid())).InstVerify(typeof(int), typeof(Guid)));
Eval((new Gen<int, RefX1<int>>(new int(), new RefX1<int>())).InstVerify(typeof(int), typeof(RefX1<int>)));
Eval((new Gen<int, RefX1<string>>(new int(), new RefX1<string>())).InstVerify(typeof(int), typeof(RefX1<string>)));
Eval((new Gen<int, RefX1<int[][, , ,][]>>(new int(), new RefX1<int[][, , ,][]>())).InstVerify(typeof(int), typeof(RefX1<int[][, , ,][]>)));
Eval((new Gen<int, ValX1<int>>(new int(), new ValX1<int>())).InstVerify(typeof(int), typeof(ValX1<int>)));
Eval((new Gen<int, ValX1<string>>(new int(), new ValX1<string>())).InstVerify(typeof(int), typeof(ValX1<string>)));
Eval((new Gen<int, ValX1<int[][, , ,][]>>(new int(), new ValX1<int[][, , ,][]>())).InstVerify(typeof(int), typeof(ValX1<int[][, , ,][]>)));
Eval((new Gen<double, int>(new double(), new int())).InstVerify(typeof(double), typeof(int)));
Eval((new Gen<double, double>(new double(), new double())).InstVerify(typeof(double), typeof(double)));
Eval((new Gen<double, string>(new double(), "string")).InstVerify(typeof(double), typeof(string)));
Eval((new Gen<double, object>(new double(), new object())).InstVerify(typeof(double), typeof(object)));
Eval((new Gen<double, Guid>(new double(), new Guid())).InstVerify(typeof(double), typeof(Guid)));
Eval((new Gen<double, RefX1<double>>(new double(), new RefX1<double>())).InstVerify(typeof(double), typeof(RefX1<double>)));
Eval((new Gen<double, RefX1<string>>(new double(), new RefX1<string>())).InstVerify(typeof(double), typeof(RefX1<string>)));
Eval((new Gen<double, RefX1<double[][, , ,][]>>(new double(), new RefX1<double[][, , ,][]>())).InstVerify(typeof(double), typeof(RefX1<double[][, , ,][]>)));
Eval((new Gen<double, ValX1<double>>(new double(), new ValX1<double>())).InstVerify(typeof(double), typeof(ValX1<double>)));
Eval((new Gen<double, ValX1<string>>(new double(), new ValX1<string>())).InstVerify(typeof(double), typeof(ValX1<string>)));
Eval((new Gen<double, ValX1<double[][, , ,][]>>(new double(), new ValX1<double[][, , ,][]>())).InstVerify(typeof(double), typeof(ValX1<double[][, , ,][]>)));
Eval((new Gen<string, int>("string", new int())).InstVerify(typeof(string), typeof(int)));
Eval((new Gen<string, double>("string", new double())).InstVerify(typeof(string), typeof(double)));
Eval((new Gen<string, string>("string", "string")).InstVerify(typeof(string), typeof(string)));
Eval((new Gen<string, object>("string", new object())).InstVerify(typeof(string), typeof(object)));
Eval((new Gen<string, Guid>("string", new Guid())).InstVerify(typeof(string), typeof(Guid)));
Eval((new Gen<string, RefX1<string>>("string", new RefX1<string>())).InstVerify(typeof(string), typeof(RefX1<string>)));
Eval((new Gen<string, RefX1<string>>("string", new RefX1<string>())).InstVerify(typeof(string), typeof(RefX1<string>)));
Eval((new Gen<string, RefX1<string[][, , ,][]>>("string", new RefX1<string[][, , ,][]>())).InstVerify(typeof(string), typeof(RefX1<string[][, , ,][]>)));
Eval((new Gen<string, ValX1<string>>("string", new ValX1<string>())).InstVerify(typeof(string), typeof(ValX1<string>)));
Eval((new Gen<string, ValX1<string>>("string", new ValX1<string>())).InstVerify(typeof(string), typeof(ValX1<string>)));
Eval((new Gen<string, ValX1<string[][, , ,][]>>("string", new ValX1<string[][, , ,][]>())).InstVerify(typeof(string), typeof(ValX1<string[][, , ,][]>)));
Eval((new Gen<object, int>(new object(), new int())).InstVerify(typeof(object), typeof(int)));
Eval((new Gen<object, double>(new object(), new double())).InstVerify(typeof(object), typeof(double)));
Eval((new Gen<object, string>(new object(), "string")).InstVerify(typeof(object), typeof(string)));
Eval((new Gen<object, object>(new object(), new object())).InstVerify(typeof(object), typeof(object)));
Eval((new Gen<object, Guid>(new object(), new Guid())).InstVerify(typeof(object), typeof(Guid)));
Eval((new Gen<object, RefX1<object>>(new object(), new RefX1<object>())).InstVerify(typeof(object), typeof(RefX1<object>)));
Eval((new Gen<object, RefX1<string>>(new object(), new RefX1<string>())).InstVerify(typeof(object), typeof(RefX1<string>)));
Eval((new Gen<object, RefX1<object[][, , ,][]>>(new object(), new RefX1<object[][, , ,][]>())).InstVerify(typeof(object), typeof(RefX1<object[][, , ,][]>)));
Eval((new Gen<object, ValX1<object>>(new object(), new ValX1<object>())).InstVerify(typeof(object), typeof(ValX1<object>)));
Eval((new Gen<object, ValX1<string>>(new object(), new ValX1<string>())).InstVerify(typeof(object), typeof(ValX1<string>)));
Eval((new Gen<object, ValX1<object[][, , ,][]>>(new object(), new ValX1<object[][, , ,][]>())).InstVerify(typeof(object), typeof(ValX1<object[][, , ,][]>)));
Eval((new Gen<Guid, int>(new Guid(), new int())).InstVerify(typeof(Guid), typeof(int)));
Eval((new Gen<Guid, double>(new Guid(), new double())).InstVerify(typeof(Guid), typeof(double)));
Eval((new Gen<Guid, string>(new Guid(), "string")).InstVerify(typeof(Guid), typeof(string)));
Eval((new Gen<Guid, object>(new Guid(), new object())).InstVerify(typeof(Guid), typeof(object)));
Eval((new Gen<Guid, Guid>(new Guid(), new Guid())).InstVerify(typeof(Guid), typeof(Guid)));
Eval((new Gen<Guid, RefX1<Guid>>(new Guid(), new RefX1<Guid>())).InstVerify(typeof(Guid), typeof(RefX1<Guid>)));
Eval((new Gen<Guid, RefX1<string>>(new Guid(), new RefX1<string>())).InstVerify(typeof(Guid), typeof(RefX1<string>)));
Eval((new Gen<Guid, RefX1<Guid[][, , ,][]>>(new Guid(), new RefX1<Guid[][, , ,][]>())).InstVerify(typeof(Guid), typeof(RefX1<Guid[][, , ,][]>)));
Eval((new Gen<Guid, ValX1<Guid>>(new Guid(), new ValX1<Guid>())).InstVerify(typeof(Guid), typeof(ValX1<Guid>)));
Eval((new Gen<Guid, ValX1<string>>(new Guid(), new ValX1<string>())).InstVerify(typeof(Guid), typeof(ValX1<string>)));
Eval((new Gen<Guid, ValX1<Guid[][, , ,][]>>(new Guid(), new ValX1<Guid[][, , ,][]>())).InstVerify(typeof(Guid), typeof(ValX1<Guid[][, , ,][]>)));
Eval((new Gen<RefX1<int>, int>(new RefX1<int>(), new int())).InstVerify(typeof(RefX1<int>), typeof(int)));
Eval((new Gen<RefX1<long>, double>(new RefX1<long>(), new double())).InstVerify(typeof(RefX1<long>), typeof(double)));
Eval((new Gen<RefX1<long>, string>(new RefX1<long>(), "string")).InstVerify(typeof(RefX1<long>), typeof(string)));
Eval((new Gen<RefX1<long>, object>(new RefX1<long>(), new object())).InstVerify(typeof(RefX1<long>), typeof(object)));
Eval((new Gen<RefX1<long>, Guid>(new RefX1<long>(), new Guid())).InstVerify(typeof(RefX1<long>), typeof(Guid)));
Eval((new Gen<RefX1<long>, RefX1<RefX1<long>>>(new RefX1<long>(), new RefX1<RefX1<long>>())).InstVerify(typeof(RefX1<long>), typeof(RefX1<RefX1<long>>)));
Eval((new Gen<RefX1<long>, RefX1<string>>(new RefX1<long>(), new RefX1<string>())).InstVerify(typeof(RefX1<long>), typeof(RefX1<string>)));
Eval((new Gen<RefX1<long>, RefX1<RefX1<long[][, , ,][]>>>(new RefX1<long>(), new RefX1<RefX1<long[][, , ,][]>>())).InstVerify(typeof(RefX1<long>), typeof(RefX1<RefX1<long[][, , ,][]>>)));
Eval((new Gen<RefX1<long>, ValX1<RefX1<long>>>(new RefX1<long>(), new ValX1<RefX1<long>>())).InstVerify(typeof(RefX1<long>), typeof(ValX1<RefX1<long>>)));
Eval((new Gen<RefX1<long>, ValX1<string>>(new RefX1<long>(), new ValX1<string>())).InstVerify(typeof(RefX1<long>), typeof(ValX1<string>)));
Eval((new Gen<RefX1<long>, ValX1<RefX1<long>[][, , ,][]>>(new RefX1<long>(), new ValX1<RefX1<long>[][, , ,][]>())).InstVerify(typeof(RefX1<long>), typeof(ValX1<RefX1<long>[][, , ,][]>)));
Eval((new Gen<ValX1<string>, int>(new ValX1<string>(), new int())).InstVerify(typeof(ValX1<string>), typeof(int)));
Eval((new Gen<ValX1<string>, double>(new ValX1<string>(), new double())).InstVerify(typeof(ValX1<string>), typeof(double)));
Eval((new Gen<ValX1<string>, string>(new ValX1<string>(), "string")).InstVerify(typeof(ValX1<string>), typeof(string)));
Eval((new Gen<ValX1<string>, object>(new ValX1<string>(), new object())).InstVerify(typeof(ValX1<string>), typeof(object)));
Eval((new Gen<ValX1<string>, Guid>(new ValX1<string>(), new Guid())).InstVerify(typeof(ValX1<string>), typeof(Guid)));
Eval((new Gen<ValX1<string>, RefX1<ValX1<string>>>(new ValX1<string>(), new RefX1<ValX1<string>>())).InstVerify(typeof(ValX1<string>), typeof(RefX1<ValX1<string>>)));
Eval((new Gen<ValX1<string>, RefX1<string>>(new ValX1<string>(), new RefX1<string>())).InstVerify(typeof(ValX1<string>), typeof(RefX1<string>)));
Eval((new Gen<ValX1<string>, RefX1<ValX1<string>[][, , ,][]>>(new ValX1<string>(), new RefX1<ValX1<string>[][, , ,][]>())).InstVerify(typeof(ValX1<string>), typeof(RefX1<ValX1<string>[][, , ,][]>)));
Eval((new Gen<ValX1<string>, ValX1<ValX1<string>>>(new ValX1<string>(), new ValX1<ValX1<string>>())).InstVerify(typeof(ValX1<string>), typeof(ValX1<ValX1<string>>)));
Eval((new Gen<ValX1<string>, ValX1<string>>(new ValX1<string>(), new ValX1<string>())).InstVerify(typeof(ValX1<string>), typeof(ValX1<string>)));
Eval((new Gen<ValX1<string>, ValX1<ValX1<string>[][, , ,][]>>(new ValX1<string>(), new ValX1<ValX1<string>[][, , ,][]>())).InstVerify(typeof(ValX1<string>), typeof(ValX1<ValX1<string>[][, , ,][]>)));
if (result)
{
Console.WriteLine("Test Passed");
return 100;
}
else
{
Console.WriteLine("Test Failed");
return 1;
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Private.Xml/tests/XmlReader/ReadContentAs/ReadAsDateTimeAttributeTests.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Xunit;
namespace System.Xml.Tests
{
public class DateTimeAttributeTests
{
[Fact]
public static void ReadContentAsDateTimeAttribute1()
{
var reader = Utils.CreateFragmentReader("<Root a=' 0002-01-01T00:00:00+00:00 '/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Equal(new DateTime(2, 1, 1, 0, 0, 0).Add(TimeZoneInfo.Local.GetUtcOffset(new DateTime(2, 1, 1))), (DateTime)reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute2()
{
var reader = Utils.CreateFragmentReader("<Root a='9998-12-31T12:59:59-00:00'/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Equal(new DateTime(9998, 12, 31, 12, 59, 59).Add(TimeZoneInfo.Local.GetUtcOffset(new DateTime(9998, 12, 31))), (DateTime)reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute3()
{
var reader = Utils.CreateFragmentReader("<Root a=' 2000-02-29T23:59:59+13:60 '/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Equal(new DateTime(2000, 2, 29, 23, 59, 59).Add(TimeZoneInfo.Local.GetUtcOffset(new DateTime(2000, 2, 29)) - new TimeSpan(14, 0, 0)), (DateTime)reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute4()
{
var reader = Utils.CreateFragmentReader("<Root a=' 00:00:00+00:00 '/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Equal(new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, 0, DateTimeKind.Utc).ToLocalTime(), (DateTime)reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute5()
{
var reader = Utils.CreateFragmentReader("<Root a='9999-31T12:59:60-11:00'/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Throws<XmlException>(() => reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute6()
{
var reader = Utils.CreateFragmentReader("<Root a=' 3000-00-29T23:59:59.999999999999-13:60 '/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Throws<XmlException>(() => reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute7()
{
var reader = Utils.CreateFragmentReader("<Root a='0000Z'/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Throws<XmlException>(() => reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute8()
{
var reader = Utils.CreateFragmentReader("<Root a=' 0001-01-01T00:00:00-99:99z '/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Throws<XmlException>(() => reader.ReadContentAs(typeof(DateTime), null));
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Xunit;
namespace System.Xml.Tests
{
public class DateTimeAttributeTests
{
[Fact]
public static void ReadContentAsDateTimeAttribute1()
{
var reader = Utils.CreateFragmentReader("<Root a=' 0002-01-01T00:00:00+00:00 '/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Equal(new DateTime(2, 1, 1, 0, 0, 0).Add(TimeZoneInfo.Local.GetUtcOffset(new DateTime(2, 1, 1))), (DateTime)reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute2()
{
var reader = Utils.CreateFragmentReader("<Root a='9998-12-31T12:59:59-00:00'/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Equal(new DateTime(9998, 12, 31, 12, 59, 59).Add(TimeZoneInfo.Local.GetUtcOffset(new DateTime(9998, 12, 31))), (DateTime)reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute3()
{
var reader = Utils.CreateFragmentReader("<Root a=' 2000-02-29T23:59:59+13:60 '/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Equal(new DateTime(2000, 2, 29, 23, 59, 59).Add(TimeZoneInfo.Local.GetUtcOffset(new DateTime(2000, 2, 29)) - new TimeSpan(14, 0, 0)), (DateTime)reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute4()
{
var reader = Utils.CreateFragmentReader("<Root a=' 00:00:00+00:00 '/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Equal(new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, 0, DateTimeKind.Utc).ToLocalTime(), (DateTime)reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute5()
{
var reader = Utils.CreateFragmentReader("<Root a='9999-31T12:59:60-11:00'/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Throws<XmlException>(() => reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute6()
{
var reader = Utils.CreateFragmentReader("<Root a=' 3000-00-29T23:59:59.999999999999-13:60 '/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Throws<XmlException>(() => reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute7()
{
var reader = Utils.CreateFragmentReader("<Root a='0000Z'/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Throws<XmlException>(() => reader.ReadContentAs(typeof(DateTime), null));
}
[Fact]
public static void ReadContentAsDateTimeAttribute8()
{
var reader = Utils.CreateFragmentReader("<Root a=' 0001-01-01T00:00:00-99:99z '/>");
reader.PositionOnElement("Root");
reader.MoveToAttribute("a");
Assert.Throws<XmlException>(() => reader.ReadContentAs(typeof(DateTime), null));
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Private.CoreLib/src/System/UnitySerializationHolder.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.Serialization;
namespace System
{
/// <summary>
/// Holds Null class for which we guarantee that there is only ever one instance of.
/// This only exists for compatibility with .NET Framework.
/// </summary>
[Serializable]
// Needs to be public to support binary serialization compatibility
public sealed class UnitySerializationHolder : ISerializable, IObjectReference
{
internal const int NullUnity = 0x0002;
private readonly int _unityType;
private readonly string? _data;
/// <summary>
/// A helper method that returns the SerializationInfo that a class utilizing
/// UnitySerializationHelper should return from a call to GetObjectData. It contains
/// the unityType (defined above) and any optional data (used only for the reflection types).
/// </summary>
internal static void GetUnitySerializationInfo(SerializationInfo info, int unityType)
{
info.SetType(typeof(UnitySerializationHolder));
info.AddValue("Data", null, typeof(string));
info.AddValue("UnityType", unityType);
info.AddValue("AssemblyName", string.Empty);
}
#pragma warning disable CA2229 // public for compat
public UnitySerializationHolder(SerializationInfo info!!, StreamingContext context)
#pragma warning restore CA2229
{
// We are ignoring any other serialization input as we are only concerned about DBNull.
// We also store data and use it for erorr logging.
_unityType = info.GetInt32("UnityType");
_data = info.GetString("Data");
}
public void GetObjectData(SerializationInfo info, StreamingContext context) =>
throw new NotSupportedException(SR.NotSupported_UnitySerHolder);
public object GetRealObject(StreamingContext context)
{
// We are only support deserializing DBNull and throwing for everything else.
if (_unityType != NullUnity)
{
throw new ArgumentException(SR.Format(SR.Argument_InvalidUnity, _data ?? "UnityType"));
}
// We are always returning the same DBNull instance.
return DBNull.Value;
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.Serialization;
namespace System
{
/// <summary>
/// Holds Null class for which we guarantee that there is only ever one instance of.
/// This only exists for compatibility with .NET Framework.
/// </summary>
[Serializable]
// Needs to be public to support binary serialization compatibility
public sealed class UnitySerializationHolder : ISerializable, IObjectReference
{
internal const int NullUnity = 0x0002;
private readonly int _unityType;
private readonly string? _data;
/// <summary>
/// A helper method that returns the SerializationInfo that a class utilizing
/// UnitySerializationHelper should return from a call to GetObjectData. It contains
/// the unityType (defined above) and any optional data (used only for the reflection types).
/// </summary>
internal static void GetUnitySerializationInfo(SerializationInfo info, int unityType)
{
info.SetType(typeof(UnitySerializationHolder));
info.AddValue("Data", null, typeof(string));
info.AddValue("UnityType", unityType);
info.AddValue("AssemblyName", string.Empty);
}
#pragma warning disable CA2229 // public for compat
public UnitySerializationHolder(SerializationInfo info!!, StreamingContext context)
#pragma warning restore CA2229
{
// We are ignoring any other serialization input as we are only concerned about DBNull.
// We also store data and use it for erorr logging.
_unityType = info.GetInt32("UnityType");
_data = info.GetString("Data");
}
public void GetObjectData(SerializationInfo info, StreamingContext context) =>
throw new NotSupportedException(SR.NotSupported_UnitySerHolder);
public object GetRealObject(StreamingContext context)
{
// We are only support deserializing DBNull and throwing for everything else.
if (_unityType != NullUnity)
{
throw new ArgumentException(SR.Format(SR.Argument_InvalidUnity, _data ?? "UnityType"));
}
// We are always returning the same DBNull instance.
return DBNull.Value;
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/HardwareIntrinsics/General/Vector64/Abs.Single.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
namespace JIT.HardwareIntrinsics.General
{
public static partial class Program
{
private static void AbsSingle()
{
var test = new VectorUnaryOpTest__AbsSingle();
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
// Validates passing a static member works
test.RunClsVarScenario();
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
// Validates passing an instance member of a class works
test.RunClassFldScenario();
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class VectorUnaryOpTest__AbsSingle
{
private struct DataTable
{
private byte[] inArray1;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Single[] inArray1, Single[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Single>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Single>();
if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Single, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<Single> _fld1;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref testStruct._fld1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
return testStruct;
}
public void RunStructFldScenario(VectorUnaryOpTest__AbsSingle testClass)
{
var result = Vector64.Abs(_fld1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr);
}
}
private static readonly int LargestVectorSize = 8;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<Single>>() / sizeof(Single);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<Single>>() / sizeof(Single);
private static Single[] _data1 = new Single[Op1ElementCount];
private static Vector64<Single> _clsVar1;
private Vector64<Single> _fld1;
private DataTable _dataTable;
static VectorUnaryOpTest__AbsSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
}
public VectorUnaryOpTest__AbsSingle()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _fld1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
_dataTable = new DataTable(_data1, new Single[RetElementCount], LargestVectorSize);
}
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = Vector64.Abs(
Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var method = typeof(Vector64).GetMethod(nameof(Vector64.Abs), new Type[] {
typeof(Vector64<Single>)
});
if (method is null)
{
method = typeof(Vector64).GetMethod(nameof(Vector64.Abs), 1, new Type[] {
typeof(Vector64<>).MakeGenericType(Type.MakeGenericMethodParameter(0))
});
}
if (method.IsGenericMethodDefinition)
{
method = method.MakeGenericMethod(typeof(Single));
}
var result = method.Invoke(null, new object[] {
Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr)
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Single>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = Vector64.Abs(
_clsVar1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr);
var result = Vector64.Abs(op1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new VectorUnaryOpTest__AbsSingle();
var result = Vector64.Abs(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = Vector64.Abs(_fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = Vector64.Abs(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
private void ValidateResult(Vector64<Single> op1, void* result, [CallerMemberName] string method = "")
{
Single[] inArray1 = new Single[Op1ElementCount];
Single[] outArray = new Single[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), op1);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Single>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "")
{
Single[] inArray1 = new Single[Op1ElementCount];
Single[] outArray = new Single[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Single>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (result[0] != Math.Abs(firstOp[0]))
{
succeeded = false;
}
else
{
for (var i = 1; i < RetElementCount; i++)
{
if (result[i] != Math.Abs(firstOp[i]))
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(Vector64)}.{nameof(Vector64.Abs)}<Single>(Vector64<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
namespace JIT.HardwareIntrinsics.General
{
public static partial class Program
{
private static void AbsSingle()
{
var test = new VectorUnaryOpTest__AbsSingle();
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
// Validates passing a static member works
test.RunClsVarScenario();
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
// Validates passing an instance member of a class works
test.RunClassFldScenario();
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class VectorUnaryOpTest__AbsSingle
{
private struct DataTable
{
private byte[] inArray1;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Single[] inArray1, Single[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Single>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Single>();
if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Single, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<Single> _fld1;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref testStruct._fld1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
return testStruct;
}
public void RunStructFldScenario(VectorUnaryOpTest__AbsSingle testClass)
{
var result = Vector64.Abs(_fld1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr);
}
}
private static readonly int LargestVectorSize = 8;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<Single>>() / sizeof(Single);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<Single>>() / sizeof(Single);
private static Single[] _data1 = new Single[Op1ElementCount];
private static Vector64<Single> _clsVar1;
private Vector64<Single> _fld1;
private DataTable _dataTable;
static VectorUnaryOpTest__AbsSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
}
public VectorUnaryOpTest__AbsSingle()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _fld1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
_dataTable = new DataTable(_data1, new Single[RetElementCount], LargestVectorSize);
}
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = Vector64.Abs(
Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var method = typeof(Vector64).GetMethod(nameof(Vector64.Abs), new Type[] {
typeof(Vector64<Single>)
});
if (method is null)
{
method = typeof(Vector64).GetMethod(nameof(Vector64.Abs), 1, new Type[] {
typeof(Vector64<>).MakeGenericType(Type.MakeGenericMethodParameter(0))
});
}
if (method.IsGenericMethodDefinition)
{
method = method.MakeGenericMethod(typeof(Single));
}
var result = method.Invoke(null, new object[] {
Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr)
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Single>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = Vector64.Abs(
_clsVar1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr);
var result = Vector64.Abs(op1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new VectorUnaryOpTest__AbsSingle();
var result = Vector64.Abs(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = Vector64.Abs(_fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = Vector64.Abs(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
private void ValidateResult(Vector64<Single> op1, void* result, [CallerMemberName] string method = "")
{
Single[] inArray1 = new Single[Op1ElementCount];
Single[] outArray = new Single[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), op1);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Single>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "")
{
Single[] inArray1 = new Single[Op1ElementCount];
Single[] outArray = new Single[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Single>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (result[0] != Math.Abs(firstOp[0]))
{
succeeded = false;
}
else
{
for (var i = 1; i < RetElementCount; i++)
{
if (result[i] != Math.Abs(firstOp[i]))
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(Vector64)}.{nameof(Vector64.Abs)}<Single>(Vector64<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDoubleTest.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// (C) 2002 Ville Palo
// (C) 2003 Martin Willemoes Hansen
//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
using System.Data.SqlTypes;
using System.Globalization;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using Xunit;
namespace System.Data.Tests.SqlTypes
{
public class SqlDoubleTest
{
private CultureInfo _originalCulture;
// Test constructor
[Fact]
public void Create()
{
SqlDouble test = new SqlDouble(34.87);
Assert.Equal(34.87D, test.Value);
test = new SqlDouble(-9000.6543);
Assert.Equal(-9000.6543D, test.Value);
}
// Test public fields
[Fact]
public void PublicFields()
{
Assert.Equal(1.7976931348623157e+308, SqlDouble.MaxValue.Value);
Assert.Equal(-1.7976931348623157e+308, SqlDouble.MinValue.Value);
Assert.True(SqlDouble.Null.IsNull);
Assert.Equal(0d, SqlDouble.Zero.Value);
}
// Test properties
[Fact]
public void Properties()
{
SqlDouble test5443 = new SqlDouble(5443e12);
SqlDouble test1 = new SqlDouble(1);
Assert.True(SqlDouble.Null.IsNull);
Assert.Equal(5443e12, test5443.Value);
Assert.Equal(1, test1.Value);
}
// PUBLIC METHODS
[Fact]
public void ArithmeticMethods()
{
SqlDouble test0 = new SqlDouble(0);
SqlDouble test1 = new SqlDouble(15E+108);
SqlDouble test2 = new SqlDouble(-65E+64);
SqlDouble test3 = new SqlDouble(5E+64);
SqlDouble test4 = new SqlDouble(5E+108);
SqlDouble testMax = new SqlDouble(SqlDouble.MaxValue.Value);
// Add()
Assert.Equal(15E+108, SqlDouble.Add(test1, test0).Value);
Assert.Equal(1.5E+109, SqlDouble.Add(test1, test2).Value);
Assert.Throws<OverflowException>(() => SqlDouble.Add(SqlDouble.MaxValue, SqlDouble.MaxValue));
// Divide()
Assert.Equal(3, SqlDouble.Divide(test1, test4));
Assert.Equal(-13d, SqlDouble.Divide(test2, test3).Value);
Assert.Throws<DivideByZeroException>(() => SqlDouble.Divide(test1, test0).Value);
// Multiply()
Assert.Equal(75E+216, SqlDouble.Multiply(test1, test4).Value);
Assert.Equal(0, SqlDouble.Multiply(test1, test0).Value);
Assert.Throws<OverflowException>(() => SqlDouble.Multiply(testMax, test1));
// Subtract()
Assert.Equal(1.5E+109, SqlDouble.Subtract(test1, test3).Value);
Assert.Throws<OverflowException>(() => SqlDouble.Subtract(SqlDouble.MinValue, SqlDouble.MaxValue));
}
[Fact]
public void CompareTo()
{
SqlDouble test1 = new SqlDouble(4e64);
SqlDouble test11 = new SqlDouble(4e64);
SqlDouble test2 = new SqlDouble(-9e34);
SqlDouble test3 = new SqlDouble(10000);
SqlString testString = new SqlString("This is a test");
Assert.True(test1.CompareTo(test3) > 0);
Assert.True(test2.CompareTo(test3) < 0);
Assert.True(test1.CompareTo(test11) == 0);
Assert.True(test11.CompareTo(SqlDouble.Null) > 0);
Assert.Throws<ArgumentException>(() => test1.CompareTo(testString));
}
[Fact]
public void EqualsMethods()
{
SqlDouble test0 = new SqlDouble(0);
SqlDouble test1 = new SqlDouble(1.58e30);
SqlDouble test2 = new SqlDouble(1.8e180);
SqlDouble test22 = new SqlDouble(1.8e180);
Assert.False(test0.Equals(test1));
Assert.False(test0.Equals((object)test1));
Assert.False(test1.Equals(test2));
Assert.False(test1.Equals((object)test2));
Assert.False(test2.Equals(new SqlString("TEST")));
Assert.True(test2.Equals(test22));
Assert.True(test2.Equals((object)test22));
// Static Equals()-method
Assert.True(SqlDouble.Equals(test2, test22).Value);
Assert.False(SqlDouble.Equals(test1, test2).Value);
}
[Fact]
public void Greaters()
{
SqlDouble test1 = new SqlDouble(1e100);
SqlDouble test11 = new SqlDouble(1e100);
SqlDouble test2 = new SqlDouble(64e164);
// GreateThan ()
Assert.False(SqlDouble.GreaterThan(test1, test2).Value);
Assert.True(SqlDouble.GreaterThan(test2, test1).Value);
Assert.False(SqlDouble.GreaterThan(test1, test11).Value);
// GreaterTharOrEqual ()
Assert.False(SqlDouble.GreaterThanOrEqual(test1, test2).Value);
Assert.True(SqlDouble.GreaterThanOrEqual(test2, test1).Value);
Assert.True(SqlDouble.GreaterThanOrEqual(test1, test11).Value);
}
[Fact]
public void Lessers()
{
SqlDouble test1 = new SqlDouble(1.8e100);
SqlDouble test11 = new SqlDouble(1.8e100);
SqlDouble test2 = new SqlDouble(64e164);
// LessThan()
Assert.False(SqlDouble.LessThan(test1, test11).Value);
Assert.False(SqlDouble.LessThan(test2, test1).Value);
Assert.True(SqlDouble.LessThan(test11, test2).Value);
// LessThanOrEqual ()
Assert.True(SqlDouble.LessThanOrEqual(test1, test2).Value);
Assert.False(SqlDouble.LessThanOrEqual(test2, test1).Value);
Assert.True(SqlDouble.LessThanOrEqual(test11, test1).Value);
Assert.True(SqlDouble.LessThanOrEqual(test11, SqlDouble.Null).IsNull);
}
[Fact]
public void NotEquals()
{
SqlDouble test1 = new SqlDouble(1280000000001);
SqlDouble test2 = new SqlDouble(128e10);
SqlDouble test22 = new SqlDouble(128e10);
Assert.True(SqlDouble.NotEquals(test1, test2).Value);
Assert.True(SqlDouble.NotEquals(test2, test1).Value);
Assert.True(SqlDouble.NotEquals(test22, test1).Value);
Assert.False(SqlDouble.NotEquals(test22, test2).Value);
Assert.False(SqlDouble.NotEquals(test2, test22).Value);
Assert.True(SqlDouble.NotEquals(SqlDouble.Null, test22).IsNull);
Assert.True(SqlDouble.NotEquals(SqlDouble.Null, test22).IsNull);
}
[Fact]
public void Parse()
{
Assert.Throws<ArgumentNullException>(() => SqlDouble.Parse(null));
Assert.Throws<FormatException>(() => SqlDouble.Parse("not-a-number"));
Assert.Throws<OverflowException>(() => SqlDouble.Parse("9e400"));
Assert.Equal(150, SqlDouble.Parse("150").Value);
}
[Fact]
public void Conversions()
{
SqlDouble test0 = new SqlDouble(0);
SqlDouble test1 = new SqlDouble(250);
SqlDouble test2 = new SqlDouble(64e64);
SqlDouble test3 = new SqlDouble(64e164);
SqlDouble TestNull = SqlDouble.Null;
// ToSqlBoolean ()
Assert.True(test1.ToSqlBoolean().Value);
Assert.False(test0.ToSqlBoolean().Value);
Assert.True(TestNull.ToSqlBoolean().IsNull);
// ToSqlByte ()
Assert.Equal((byte)250, test1.ToSqlByte().Value);
Assert.Equal((byte)0, test0.ToSqlByte().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlByte());
// ToSqlDecimal ()
Assert.Equal(250M, test1.ToSqlDecimal().Value);
Assert.Equal(0, test0.ToSqlDecimal().Value);
Assert.Throws<OverflowException>(() => test3.ToSqlDecimal());
// ToSqlInt16 ()
Assert.Equal((short)250, test1.ToSqlInt16().Value);
Assert.Equal((short)0, test0.ToSqlInt16().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlInt16());
// ToSqlInt32 ()
Assert.Equal(250, test1.ToSqlInt32().Value);
Assert.Equal(0, test0.ToSqlInt32().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlInt32());
// ToSqlInt64 ()
Assert.Equal(250, test1.ToSqlInt64().Value);
Assert.Equal(0, test0.ToSqlInt64().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlInt64());
// ToSqlMoney ()
Assert.Equal(250M, test1.ToSqlMoney().Value);
Assert.Equal(0, test0.ToSqlMoney().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlMoney());
// ToSqlSingle ()
Assert.Equal(250, test1.ToSqlSingle().Value);
Assert.Equal(0, test0.ToSqlSingle().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlSingle());
// ToSqlString ()
Assert.Equal(250.ToString(), test1.ToSqlString().Value);
Assert.Equal(0.ToString(), test0.ToSqlString().Value);
Assert.Equal(6.4E+65.ToString(), test2.ToSqlString().Value);
// ToString ()
Assert.Equal(250.ToString(), test1.ToString());
Assert.Equal(0.ToString(), test0.ToString());
Assert.Equal(6.4E+65.ToString(), test2.ToString());
}
// OPERATORS
[Fact]
public void ArithmeticOperators()
{
SqlDouble test0 = new SqlDouble(0);
SqlDouble test1 = new SqlDouble(24E+100);
SqlDouble test3 = new SqlDouble(12E+100);
SqlDouble test4 = new SqlDouble(1E+10);
SqlDouble test5 = new SqlDouble(2E+10);
// "+"-operator
Assert.Equal(3E+10, test4 + test5);
Assert.Throws<OverflowException>(() => SqlDouble.MaxValue + SqlDouble.MaxValue);
// "/"-operator
Assert.Equal(2, test1 / test3);
Assert.Throws<DivideByZeroException>(() => test3 / test0);
// "*"-operator
Assert.Equal(2e20, test4 * test5);
Assert.Throws<OverflowException>(() => SqlDouble.MaxValue * test1);
// "-"-operator
Assert.Equal(12e100, test1 - test3);
Assert.Throws<OverflowException>(() => SqlDouble.MinValue - SqlDouble.MaxValue);
}
[Fact]
public void ThanOrEqualOperators()
{
SqlDouble test1 = new SqlDouble(1E+164);
SqlDouble test2 = new SqlDouble(9.7E+100);
SqlDouble test22 = new SqlDouble(9.7E+100);
SqlDouble test3 = new SqlDouble(2E+200);
// == -operator
Assert.True((test2 == test22).Value);
Assert.False((test1 == test2).Value);
Assert.True((test1 == SqlDouble.Null).IsNull);
// != -operator
Assert.False((test2 != test22).Value);
Assert.True((test2 != test3).Value);
Assert.True((test1 != test3).Value);
Assert.True((test1 != SqlDouble.Null).IsNull);
// > -operator
Assert.True((test1 > test2).Value);
Assert.False((test1 > test3).Value);
Assert.False((test2 > test22).Value);
Assert.True((test1 > SqlDouble.Null).IsNull);
// >= -operator
Assert.False((test1 >= test3).Value);
Assert.True((test3 >= test1).Value);
Assert.True((test2 >= test22).Value);
Assert.True((test1 >= SqlDouble.Null).IsNull);
// < -operator
Assert.False((test1 < test2).Value);
Assert.True((test1 < test3).Value);
Assert.False((test2 < test22).Value);
Assert.True((test1 < SqlDouble.Null).IsNull);
// <= -operator
Assert.True((test1 <= test3).Value);
Assert.False((test3 <= test1).Value);
Assert.True((test2 <= test22).Value);
Assert.True((test1 <= SqlDouble.Null).IsNull);
}
[Fact]
public void UnaryNegation()
{
SqlDouble test = new SqlDouble(2000000001);
SqlDouble testNeg = new SqlDouble(-3000);
SqlDouble result = -test;
Assert.Equal(-2000000001, result.Value);
result = -testNeg;
Assert.Equal(3000, result.Value);
}
[Fact]
public void SqlBooleanToSqlDouble()
{
SqlBoolean testBoolean = new SqlBoolean(true);
SqlDouble result;
result = (SqlDouble)testBoolean;
Assert.Equal(1, result.Value);
result = (SqlDouble)SqlBoolean.Null;
Assert.True(result.IsNull);
}
[Fact]
public void SqlDoubleToDouble()
{
SqlDouble test = new SqlDouble(12e12);
double result = (double)test;
Assert.Equal(12e12, result);
}
[Fact]
public void SqlStringToSqlDouble()
{
SqlString testString = new SqlString("Test string");
SqlString testString100 = new SqlString("100");
Assert.Equal(100, ((SqlDouble)testString100).Value);
Assert.Throws<FormatException>(() => (SqlDouble)testString);
}
[Fact]
public void DoubleToSqlDouble()
{
double test1 = 5e64;
SqlDouble result = test1;
Assert.Equal(5e64, result.Value);
}
[Fact]
public void ByteToSqlDouble()
{
short TestShort = 14;
Assert.Equal(14, ((SqlDouble)TestShort).Value);
}
[Fact]
public void SqlDecimalToSqlDouble()
{
SqlDecimal TestDecimal64 = new SqlDecimal(64);
Assert.Equal(64, ((SqlDouble)TestDecimal64).Value);
Assert.Equal(SqlDouble.Null, SqlDecimal.Null);
}
[Fact]
public void SqlIntToSqlDouble()
{
SqlInt16 Test64 = new SqlInt16(64);
SqlInt32 Test640 = new SqlInt32(640);
SqlInt64 Test64000 = new SqlInt64(64000);
Assert.Equal(64, ((SqlDouble)Test64).Value);
Assert.Equal(640, ((SqlDouble)Test640).Value);
Assert.Equal(64000, ((SqlDouble)Test64000).Value);
}
[Fact]
public void SqlMoneyToSqlDouble()
{
SqlMoney TestMoney64 = new SqlMoney(64);
Assert.Equal(64, ((SqlDouble)TestMoney64).Value);
}
[Fact]
public void SqlSingleToSqlDouble()
{
SqlSingle TestSingle64 = new SqlSingle(64);
Assert.Equal(64, ((SqlDouble)TestSingle64).Value);
}
[Fact]
public void GetXsdTypeTest()
{
XmlQualifiedName qualifiedName = SqlDouble.GetXsdType(null);
Assert.Equal("double", qualifiedName.Name);
}
internal void ReadWriteXmlTestInternal(string xml,
double testval,
string unit_test_id)
{
SqlDouble test;
SqlDouble test1;
XmlSerializer ser;
StringWriter sw;
XmlTextWriter xw;
StringReader sr;
XmlTextReader xr;
test = new SqlDouble(testval);
ser = new XmlSerializer(typeof(SqlDouble));
sw = new StringWriter();
xw = new XmlTextWriter(sw);
ser.Serialize(xw, test);
// Assert.Equal (xml, sw.ToString ());
sr = new StringReader(xml);
xr = new XmlTextReader(sr);
test1 = (SqlDouble)ser.Deserialize(xr);
Assert.Equal(testval, test1.Value);
}
[Fact]
//[Category ("MobileNotWorking")]
public void ReadWriteXmlTest()
{
string xml1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><double>4556.99999999999999999988</double>";
string xml2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><double>-6445.8888888888899999999</double>";
string xml3 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><double>0x455687AB3E4D56F</double>";
double test1 = 4556.99999999999999999988;
double test2 = -6445.8888888888899999999;
double test3 = 0x4F56;
ReadWriteXmlTestInternal(xml1, test1, "BA01");
ReadWriteXmlTestInternal(xml2, test2, "BA02");
InvalidOperationException ex =
Assert.Throws<InvalidOperationException>(() => ReadWriteXmlTestInternal(xml3, test3, "BA03"));
Assert.Equal(typeof(FormatException), ex.InnerException.GetType());
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// (C) 2002 Ville Palo
// (C) 2003 Martin Willemoes Hansen
//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
using System.Data.SqlTypes;
using System.Globalization;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using Xunit;
namespace System.Data.Tests.SqlTypes
{
public class SqlDoubleTest
{
private CultureInfo _originalCulture;
// Test constructor
[Fact]
public void Create()
{
SqlDouble test = new SqlDouble(34.87);
Assert.Equal(34.87D, test.Value);
test = new SqlDouble(-9000.6543);
Assert.Equal(-9000.6543D, test.Value);
}
// Test public fields
[Fact]
public void PublicFields()
{
Assert.Equal(1.7976931348623157e+308, SqlDouble.MaxValue.Value);
Assert.Equal(-1.7976931348623157e+308, SqlDouble.MinValue.Value);
Assert.True(SqlDouble.Null.IsNull);
Assert.Equal(0d, SqlDouble.Zero.Value);
}
// Test properties
[Fact]
public void Properties()
{
SqlDouble test5443 = new SqlDouble(5443e12);
SqlDouble test1 = new SqlDouble(1);
Assert.True(SqlDouble.Null.IsNull);
Assert.Equal(5443e12, test5443.Value);
Assert.Equal(1, test1.Value);
}
// PUBLIC METHODS
[Fact]
public void ArithmeticMethods()
{
SqlDouble test0 = new SqlDouble(0);
SqlDouble test1 = new SqlDouble(15E+108);
SqlDouble test2 = new SqlDouble(-65E+64);
SqlDouble test3 = new SqlDouble(5E+64);
SqlDouble test4 = new SqlDouble(5E+108);
SqlDouble testMax = new SqlDouble(SqlDouble.MaxValue.Value);
// Add()
Assert.Equal(15E+108, SqlDouble.Add(test1, test0).Value);
Assert.Equal(1.5E+109, SqlDouble.Add(test1, test2).Value);
Assert.Throws<OverflowException>(() => SqlDouble.Add(SqlDouble.MaxValue, SqlDouble.MaxValue));
// Divide()
Assert.Equal(3, SqlDouble.Divide(test1, test4));
Assert.Equal(-13d, SqlDouble.Divide(test2, test3).Value);
Assert.Throws<DivideByZeroException>(() => SqlDouble.Divide(test1, test0).Value);
// Multiply()
Assert.Equal(75E+216, SqlDouble.Multiply(test1, test4).Value);
Assert.Equal(0, SqlDouble.Multiply(test1, test0).Value);
Assert.Throws<OverflowException>(() => SqlDouble.Multiply(testMax, test1));
// Subtract()
Assert.Equal(1.5E+109, SqlDouble.Subtract(test1, test3).Value);
Assert.Throws<OverflowException>(() => SqlDouble.Subtract(SqlDouble.MinValue, SqlDouble.MaxValue));
}
[Fact]
public void CompareTo()
{
SqlDouble test1 = new SqlDouble(4e64);
SqlDouble test11 = new SqlDouble(4e64);
SqlDouble test2 = new SqlDouble(-9e34);
SqlDouble test3 = new SqlDouble(10000);
SqlString testString = new SqlString("This is a test");
Assert.True(test1.CompareTo(test3) > 0);
Assert.True(test2.CompareTo(test3) < 0);
Assert.True(test1.CompareTo(test11) == 0);
Assert.True(test11.CompareTo(SqlDouble.Null) > 0);
Assert.Throws<ArgumentException>(() => test1.CompareTo(testString));
}
[Fact]
public void EqualsMethods()
{
SqlDouble test0 = new SqlDouble(0);
SqlDouble test1 = new SqlDouble(1.58e30);
SqlDouble test2 = new SqlDouble(1.8e180);
SqlDouble test22 = new SqlDouble(1.8e180);
Assert.False(test0.Equals(test1));
Assert.False(test0.Equals((object)test1));
Assert.False(test1.Equals(test2));
Assert.False(test1.Equals((object)test2));
Assert.False(test2.Equals(new SqlString("TEST")));
Assert.True(test2.Equals(test22));
Assert.True(test2.Equals((object)test22));
// Static Equals()-method
Assert.True(SqlDouble.Equals(test2, test22).Value);
Assert.False(SqlDouble.Equals(test1, test2).Value);
}
[Fact]
public void Greaters()
{
SqlDouble test1 = new SqlDouble(1e100);
SqlDouble test11 = new SqlDouble(1e100);
SqlDouble test2 = new SqlDouble(64e164);
// GreateThan ()
Assert.False(SqlDouble.GreaterThan(test1, test2).Value);
Assert.True(SqlDouble.GreaterThan(test2, test1).Value);
Assert.False(SqlDouble.GreaterThan(test1, test11).Value);
// GreaterTharOrEqual ()
Assert.False(SqlDouble.GreaterThanOrEqual(test1, test2).Value);
Assert.True(SqlDouble.GreaterThanOrEqual(test2, test1).Value);
Assert.True(SqlDouble.GreaterThanOrEqual(test1, test11).Value);
}
[Fact]
public void Lessers()
{
SqlDouble test1 = new SqlDouble(1.8e100);
SqlDouble test11 = new SqlDouble(1.8e100);
SqlDouble test2 = new SqlDouble(64e164);
// LessThan()
Assert.False(SqlDouble.LessThan(test1, test11).Value);
Assert.False(SqlDouble.LessThan(test2, test1).Value);
Assert.True(SqlDouble.LessThan(test11, test2).Value);
// LessThanOrEqual ()
Assert.True(SqlDouble.LessThanOrEqual(test1, test2).Value);
Assert.False(SqlDouble.LessThanOrEqual(test2, test1).Value);
Assert.True(SqlDouble.LessThanOrEqual(test11, test1).Value);
Assert.True(SqlDouble.LessThanOrEqual(test11, SqlDouble.Null).IsNull);
}
[Fact]
public void NotEquals()
{
SqlDouble test1 = new SqlDouble(1280000000001);
SqlDouble test2 = new SqlDouble(128e10);
SqlDouble test22 = new SqlDouble(128e10);
Assert.True(SqlDouble.NotEquals(test1, test2).Value);
Assert.True(SqlDouble.NotEquals(test2, test1).Value);
Assert.True(SqlDouble.NotEquals(test22, test1).Value);
Assert.False(SqlDouble.NotEquals(test22, test2).Value);
Assert.False(SqlDouble.NotEquals(test2, test22).Value);
Assert.True(SqlDouble.NotEquals(SqlDouble.Null, test22).IsNull);
Assert.True(SqlDouble.NotEquals(SqlDouble.Null, test22).IsNull);
}
[Fact]
public void Parse()
{
Assert.Throws<ArgumentNullException>(() => SqlDouble.Parse(null));
Assert.Throws<FormatException>(() => SqlDouble.Parse("not-a-number"));
Assert.Throws<OverflowException>(() => SqlDouble.Parse("9e400"));
Assert.Equal(150, SqlDouble.Parse("150").Value);
}
[Fact]
public void Conversions()
{
SqlDouble test0 = new SqlDouble(0);
SqlDouble test1 = new SqlDouble(250);
SqlDouble test2 = new SqlDouble(64e64);
SqlDouble test3 = new SqlDouble(64e164);
SqlDouble TestNull = SqlDouble.Null;
// ToSqlBoolean ()
Assert.True(test1.ToSqlBoolean().Value);
Assert.False(test0.ToSqlBoolean().Value);
Assert.True(TestNull.ToSqlBoolean().IsNull);
// ToSqlByte ()
Assert.Equal((byte)250, test1.ToSqlByte().Value);
Assert.Equal((byte)0, test0.ToSqlByte().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlByte());
// ToSqlDecimal ()
Assert.Equal(250M, test1.ToSqlDecimal().Value);
Assert.Equal(0, test0.ToSqlDecimal().Value);
Assert.Throws<OverflowException>(() => test3.ToSqlDecimal());
// ToSqlInt16 ()
Assert.Equal((short)250, test1.ToSqlInt16().Value);
Assert.Equal((short)0, test0.ToSqlInt16().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlInt16());
// ToSqlInt32 ()
Assert.Equal(250, test1.ToSqlInt32().Value);
Assert.Equal(0, test0.ToSqlInt32().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlInt32());
// ToSqlInt64 ()
Assert.Equal(250, test1.ToSqlInt64().Value);
Assert.Equal(0, test0.ToSqlInt64().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlInt64());
// ToSqlMoney ()
Assert.Equal(250M, test1.ToSqlMoney().Value);
Assert.Equal(0, test0.ToSqlMoney().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlMoney());
// ToSqlSingle ()
Assert.Equal(250, test1.ToSqlSingle().Value);
Assert.Equal(0, test0.ToSqlSingle().Value);
Assert.Throws<OverflowException>(() => test2.ToSqlSingle());
// ToSqlString ()
Assert.Equal(250.ToString(), test1.ToSqlString().Value);
Assert.Equal(0.ToString(), test0.ToSqlString().Value);
Assert.Equal(6.4E+65.ToString(), test2.ToSqlString().Value);
// ToString ()
Assert.Equal(250.ToString(), test1.ToString());
Assert.Equal(0.ToString(), test0.ToString());
Assert.Equal(6.4E+65.ToString(), test2.ToString());
}
// OPERATORS
[Fact]
public void ArithmeticOperators()
{
SqlDouble test0 = new SqlDouble(0);
SqlDouble test1 = new SqlDouble(24E+100);
SqlDouble test3 = new SqlDouble(12E+100);
SqlDouble test4 = new SqlDouble(1E+10);
SqlDouble test5 = new SqlDouble(2E+10);
// "+"-operator
Assert.Equal(3E+10, test4 + test5);
Assert.Throws<OverflowException>(() => SqlDouble.MaxValue + SqlDouble.MaxValue);
// "/"-operator
Assert.Equal(2, test1 / test3);
Assert.Throws<DivideByZeroException>(() => test3 / test0);
// "*"-operator
Assert.Equal(2e20, test4 * test5);
Assert.Throws<OverflowException>(() => SqlDouble.MaxValue * test1);
// "-"-operator
Assert.Equal(12e100, test1 - test3);
Assert.Throws<OverflowException>(() => SqlDouble.MinValue - SqlDouble.MaxValue);
}
[Fact]
public void ThanOrEqualOperators()
{
SqlDouble test1 = new SqlDouble(1E+164);
SqlDouble test2 = new SqlDouble(9.7E+100);
SqlDouble test22 = new SqlDouble(9.7E+100);
SqlDouble test3 = new SqlDouble(2E+200);
// == -operator
Assert.True((test2 == test22).Value);
Assert.False((test1 == test2).Value);
Assert.True((test1 == SqlDouble.Null).IsNull);
// != -operator
Assert.False((test2 != test22).Value);
Assert.True((test2 != test3).Value);
Assert.True((test1 != test3).Value);
Assert.True((test1 != SqlDouble.Null).IsNull);
// > -operator
Assert.True((test1 > test2).Value);
Assert.False((test1 > test3).Value);
Assert.False((test2 > test22).Value);
Assert.True((test1 > SqlDouble.Null).IsNull);
// >= -operator
Assert.False((test1 >= test3).Value);
Assert.True((test3 >= test1).Value);
Assert.True((test2 >= test22).Value);
Assert.True((test1 >= SqlDouble.Null).IsNull);
// < -operator
Assert.False((test1 < test2).Value);
Assert.True((test1 < test3).Value);
Assert.False((test2 < test22).Value);
Assert.True((test1 < SqlDouble.Null).IsNull);
// <= -operator
Assert.True((test1 <= test3).Value);
Assert.False((test3 <= test1).Value);
Assert.True((test2 <= test22).Value);
Assert.True((test1 <= SqlDouble.Null).IsNull);
}
[Fact]
public void UnaryNegation()
{
SqlDouble test = new SqlDouble(2000000001);
SqlDouble testNeg = new SqlDouble(-3000);
SqlDouble result = -test;
Assert.Equal(-2000000001, result.Value);
result = -testNeg;
Assert.Equal(3000, result.Value);
}
[Fact]
public void SqlBooleanToSqlDouble()
{
SqlBoolean testBoolean = new SqlBoolean(true);
SqlDouble result;
result = (SqlDouble)testBoolean;
Assert.Equal(1, result.Value);
result = (SqlDouble)SqlBoolean.Null;
Assert.True(result.IsNull);
}
[Fact]
public void SqlDoubleToDouble()
{
SqlDouble test = new SqlDouble(12e12);
double result = (double)test;
Assert.Equal(12e12, result);
}
[Fact]
public void SqlStringToSqlDouble()
{
SqlString testString = new SqlString("Test string");
SqlString testString100 = new SqlString("100");
Assert.Equal(100, ((SqlDouble)testString100).Value);
Assert.Throws<FormatException>(() => (SqlDouble)testString);
}
[Fact]
public void DoubleToSqlDouble()
{
double test1 = 5e64;
SqlDouble result = test1;
Assert.Equal(5e64, result.Value);
}
[Fact]
public void ByteToSqlDouble()
{
short TestShort = 14;
Assert.Equal(14, ((SqlDouble)TestShort).Value);
}
[Fact]
public void SqlDecimalToSqlDouble()
{
SqlDecimal TestDecimal64 = new SqlDecimal(64);
Assert.Equal(64, ((SqlDouble)TestDecimal64).Value);
Assert.Equal(SqlDouble.Null, SqlDecimal.Null);
}
[Fact]
public void SqlIntToSqlDouble()
{
SqlInt16 Test64 = new SqlInt16(64);
SqlInt32 Test640 = new SqlInt32(640);
SqlInt64 Test64000 = new SqlInt64(64000);
Assert.Equal(64, ((SqlDouble)Test64).Value);
Assert.Equal(640, ((SqlDouble)Test640).Value);
Assert.Equal(64000, ((SqlDouble)Test64000).Value);
}
[Fact]
public void SqlMoneyToSqlDouble()
{
SqlMoney TestMoney64 = new SqlMoney(64);
Assert.Equal(64, ((SqlDouble)TestMoney64).Value);
}
[Fact]
public void SqlSingleToSqlDouble()
{
SqlSingle TestSingle64 = new SqlSingle(64);
Assert.Equal(64, ((SqlDouble)TestSingle64).Value);
}
[Fact]
public void GetXsdTypeTest()
{
XmlQualifiedName qualifiedName = SqlDouble.GetXsdType(null);
Assert.Equal("double", qualifiedName.Name);
}
internal void ReadWriteXmlTestInternal(string xml,
double testval,
string unit_test_id)
{
SqlDouble test;
SqlDouble test1;
XmlSerializer ser;
StringWriter sw;
XmlTextWriter xw;
StringReader sr;
XmlTextReader xr;
test = new SqlDouble(testval);
ser = new XmlSerializer(typeof(SqlDouble));
sw = new StringWriter();
xw = new XmlTextWriter(sw);
ser.Serialize(xw, test);
// Assert.Equal (xml, sw.ToString ());
sr = new StringReader(xml);
xr = new XmlTextReader(sr);
test1 = (SqlDouble)ser.Deserialize(xr);
Assert.Equal(testval, test1.Value);
}
[Fact]
//[Category ("MobileNotWorking")]
public void ReadWriteXmlTest()
{
string xml1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><double>4556.99999999999999999988</double>";
string xml2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><double>-6445.8888888888899999999</double>";
string xml3 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><double>0x455687AB3E4D56F</double>";
double test1 = 4556.99999999999999999988;
double test2 = -6445.8888888888899999999;
double test3 = 0x4F56;
ReadWriteXmlTestInternal(xml1, test1, "BA01");
ReadWriteXmlTestInternal(xml2, test2, "BA02");
InvalidOperationException ex =
Assert.Throws<InvalidOperationException>(() => ReadWriteXmlTestInternal(xml3, test3, "BA03"));
Assert.Equal(typeof(FormatException), ex.InnerException.GetType());
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComImportAttribute.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
namespace System.Runtime.InteropServices
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, Inherited = false)]
public sealed class ComImportAttribute : Attribute
{
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
namespace System.Runtime.InteropServices
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, Inherited = false)]
public sealed class ComImportAttribute : Attribute
{
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/mono/mono/tests/assembly-load-dir2/LibStrongName.cs
|
using System.Reflection;
[assembly:AssemblyVersion("2.0.0.0")]
public class LibClass {
public int InAllVersions;
public int OnlyInVersion2;
public LibClass () {}
}
|
using System.Reflection;
[assembly:AssemblyVersion("2.0.0.0")]
public class LibClass {
public int InAllVersions;
public int OnlyInVersion2;
public LibClass () {}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/Generics/Instantiation/delegates/Delegate032.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
internal delegate T GenDelegate<T>(T p1, out T p2);
internal struct Foo<T>
{
static public T Function<U>(U i, out U j)
{
j = i;
return (T)(Object)i;
}
}
internal class Test_Delegate032
{
public static int Main()
{
int i, j;
GenDelegate<int> MyDelegate = new GenDelegate<int>(Foo<int>.Function<int>);
i = MyDelegate(10, out j);
if ((i != 10) || (j != 10))
{
Console.WriteLine("Failed Sync Invokation");
return 1;
}
Console.WriteLine("Test Passes");
return 100;
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
internal delegate T GenDelegate<T>(T p1, out T p2);
internal struct Foo<T>
{
static public T Function<U>(U i, out U j)
{
j = i;
return (T)(Object)i;
}
}
internal class Test_Delegate032
{
public static int Main()
{
int i, j;
GenDelegate<int> MyDelegate = new GenDelegate<int>(Foo<int>.Function<int>);
i = MyDelegate(10, out j);
if ((i != 10) || (j != 10))
{
Console.WriteLine("Failed Sync Invokation");
return 1;
}
Console.WriteLine("Test Passes");
return 100;
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/Regression/CLR-x86-JIT/V1-M10/b06924/b06924.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
namespace AAAA
{
//@BEGINRENAME; Verify this renames
//@ENDRENAME; Verify this renames
using System;
public class CtTest
{
private static int iTest = 5;
public static int Main(String[] args)
{
iTest++;
Console.WriteLine("iTest is " + iTest);
return 100;
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
namespace AAAA
{
//@BEGINRENAME; Verify this renames
//@ENDRENAME; Verify this renames
using System;
public class CtTest
{
private static int iTest = 5;
public static int Main(String[] args)
{
iTest++;
Console.WriteLine("iTest is " + iTest);
return 100;
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/GC/Regressions/v2.0-beta2/471729/471729.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<GCStressIncompatible>true</GCStressIncompatible>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
<Compile Include="$(MSBuildProjectName).cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<GCStressIncompatible>true</GCStressIncompatible>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
<Compile Include="$(MSBuildProjectName).cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd.Arm64/MultiplyExtendedScalarBySelectedScalar.Vector64.Double.Vector128.Double.1.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1()
{
var test = new ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle2;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Double[] inArray1, Double[] inArray2, Double[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Double>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<Double>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Double>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Double, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<Double, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<Double> _fld1;
public Vector128<Double> _fld2;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref testStruct._fld1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref testStruct._fld2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
return testStruct;
}
public void RunStructFldScenario(ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1 testClass)
{
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(_fld1, _fld2, 1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1 testClass)
{
fixed (Vector64<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(pFld1)),
AdvSimd.LoadVector128((Double*)(pFld2)),
1
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<Double>>() / sizeof(Double);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector128<Double>>() / sizeof(Double);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<Double>>() / sizeof(Double);
private static readonly byte Imm = 1;
private static Double[] _data1 = new Double[Op1ElementCount];
private static Double[] _data2 = new Double[Op2ElementCount];
private static Vector64<Double> _clsVar1;
private static Vector128<Double> _clsVar2;
private Vector64<Double> _fld1;
private Vector128<Double> _fld2;
private DataTable _dataTable;
static ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
public ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref _fld1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _fld2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
_dataTable = new DataTable(_data1, _data2, new Double[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.Arm64.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
Unsafe.Read<Vector64<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Double*)(_dataTable.inArray2Ptr)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar), new Type[] { typeof(Vector64<Double>), typeof(Vector128<Double>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Double>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar), new Type[] { typeof(Vector64<Double>), typeof(Vector128<Double>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Double*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Double*)(_dataTable.inArray2Ptr)),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Double>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
_clsVar1,
_clsVar2,
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector64<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(pClsVar1)),
AdvSimd.LoadVector128((Double*)(pClsVar2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<Double>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(op1, op2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector64((Double*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Double*)(_dataTable.inArray2Ptr));
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(op1, op2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1();
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(test._fld1, test._fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1();
fixed (Vector64<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(pFld1)),
AdvSimd.LoadVector128((Double*)(pFld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(_fld1, _fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector64<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(pFld1)),
AdvSimd.LoadVector128((Double*)(pFld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(test._fld1, test._fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(&test._fld1)),
AdvSimd.LoadVector128((Double*)(&test._fld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector64<Double> firstOp, Vector128<Double> secondOp, void* result, [CallerMemberName] string method = "")
{
Double[] inArray1 = new Double[Op1ElementCount];
Double[] inArray2 = new Double[Op2ElementCount];
Double[] outArray = new Double[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Double, byte>(ref inArray1[0]), firstOp);
Unsafe.WriteUnaligned(ref Unsafe.As<Double, byte>(ref inArray2[0]), secondOp);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Double>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(void* firstOp, void* secondOp, void* result, [CallerMemberName] string method = "")
{
Double[] inArray1 = new Double[Op1ElementCount];
Double[] inArray2 = new Double[Op2ElementCount];
Double[] outArray = new Double[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(firstOp), (uint)Unsafe.SizeOf<Vector64<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(secondOp), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Double>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (BitConverter.DoubleToInt64Bits(Helpers.MultiplyExtended(firstOp[0], secondOp[Imm])) != BitConverter.DoubleToInt64Bits(result[0]))
{
succeeded = false;
}
else
{
for (var i = 1; i < RetElementCount; i++)
{
if (BitConverter.DoubleToInt64Bits(result[i]) != 0)
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd.Arm64)}.{nameof(AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar)}<Double>(Vector64<Double>, Vector128<Double>, 1): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1()
{
var test = new ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle2;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Double[] inArray1, Double[] inArray2, Double[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Double>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<Double>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Double>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Double, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<Double, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<Double> _fld1;
public Vector128<Double> _fld2;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref testStruct._fld1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref testStruct._fld2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
return testStruct;
}
public void RunStructFldScenario(ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1 testClass)
{
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(_fld1, _fld2, 1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1 testClass)
{
fixed (Vector64<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(pFld1)),
AdvSimd.LoadVector128((Double*)(pFld2)),
1
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<Double>>() / sizeof(Double);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector128<Double>>() / sizeof(Double);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<Double>>() / sizeof(Double);
private static readonly byte Imm = 1;
private static Double[] _data1 = new Double[Op1ElementCount];
private static Double[] _data2 = new Double[Op2ElementCount];
private static Vector64<Double> _clsVar1;
private static Vector128<Double> _clsVar2;
private Vector64<Double> _fld1;
private Vector128<Double> _fld2;
private DataTable _dataTable;
static ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
public ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref _fld1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _fld2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
_dataTable = new DataTable(_data1, _data2, new Double[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.Arm64.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
Unsafe.Read<Vector64<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Double*)(_dataTable.inArray2Ptr)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar), new Type[] { typeof(Vector64<Double>), typeof(Vector128<Double>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Double>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar), new Type[] { typeof(Vector64<Double>), typeof(Vector128<Double>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Double*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Double*)(_dataTable.inArray2Ptr)),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Double>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
_clsVar1,
_clsVar2,
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector64<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(pClsVar1)),
AdvSimd.LoadVector128((Double*)(pClsVar2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<Double>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(op1, op2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector64((Double*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Double*)(_dataTable.inArray2Ptr));
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(op1, op2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1();
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(test._fld1, test._fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new ImmBinaryOpTest__MultiplyExtendedScalarBySelectedScalar_Vector64_Double_Vector128_Double_1();
fixed (Vector64<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(pFld1)),
AdvSimd.LoadVector128((Double*)(pFld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(_fld1, _fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector64<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(pFld1)),
AdvSimd.LoadVector128((Double*)(pFld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(test._fld1, test._fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar(
AdvSimd.LoadVector64((Double*)(&test._fld1)),
AdvSimd.LoadVector128((Double*)(&test._fld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector64<Double> firstOp, Vector128<Double> secondOp, void* result, [CallerMemberName] string method = "")
{
Double[] inArray1 = new Double[Op1ElementCount];
Double[] inArray2 = new Double[Op2ElementCount];
Double[] outArray = new Double[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Double, byte>(ref inArray1[0]), firstOp);
Unsafe.WriteUnaligned(ref Unsafe.As<Double, byte>(ref inArray2[0]), secondOp);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Double>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(void* firstOp, void* secondOp, void* result, [CallerMemberName] string method = "")
{
Double[] inArray1 = new Double[Op1ElementCount];
Double[] inArray2 = new Double[Op2ElementCount];
Double[] outArray = new Double[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(firstOp), (uint)Unsafe.SizeOf<Vector64<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(secondOp), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Double>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (BitConverter.DoubleToInt64Bits(Helpers.MultiplyExtended(firstOp[0], secondOp[Imm])) != BitConverter.DoubleToInt64Bits(result[0]))
{
succeeded = false;
}
else
{
for (var i = 1; i < RetElementCount; i++)
{
if (BitConverter.DoubleToInt64Bits(result[i]) != 0)
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd.Arm64)}.{nameof(AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar)}<Double>(Vector64<Double>, Vector128<Double>, 1): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/jit64/valuetypes/nullable/castclass/castclass/castclass021.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.InteropServices;
using System;
internal class NullableTest
{
private static bool BoxUnboxToNQ(object o)
{
return Helper.Compare((EmptyStruct)(ValueType)o, Helper.Create(default(EmptyStruct)));
}
private static bool BoxUnboxToQ(object o)
{
return Helper.Compare((EmptyStruct?)(ValueType)o, Helper.Create(default(EmptyStruct)));
}
private static int Main()
{
EmptyStruct? s = Helper.Create(default(EmptyStruct));
if (BoxUnboxToNQ(s) && BoxUnboxToQ(s))
return ExitCode.Passed;
else
return ExitCode.Failed;
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.InteropServices;
using System;
internal class NullableTest
{
private static bool BoxUnboxToNQ(object o)
{
return Helper.Compare((EmptyStruct)(ValueType)o, Helper.Create(default(EmptyStruct)));
}
private static bool BoxUnboxToQ(object o)
{
return Helper.Compare((EmptyStruct?)(ValueType)o, Helper.Create(default(EmptyStruct)));
}
private static int Main()
{
EmptyStruct? s = Helper.Create(default(EmptyStruct));
if (BoxUnboxToNQ(s) && BoxUnboxToQ(s))
return ExitCode.Passed;
else
return ExitCode.Failed;
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightArithmeticNarrowingSaturateLower.Vector64.SByte.1.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1()
{
var test = new ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1
{
private struct DataTable
{
private byte[] inArray;
private byte[] outArray;
private GCHandle inHandle;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Int16[] inArray, SByte[] outArray, int alignment)
{
int sizeOfinArray = inArray.Length * Unsafe.SizeOf<Int16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<SByte>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle = GCHandle.Alloc(this.inArray, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArrayPtr), ref Unsafe.As<Int16, byte>(ref inArray[0]), (uint)sizeOfinArray);
}
public void* inArrayPtr => Align((byte*)(inHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<Int16> _fld;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref testStruct._fld), ref Unsafe.As<Int16, byte>(ref _data[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
return testStruct;
}
public void RunStructFldScenario(ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1 testClass)
{
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(_fld, 1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1 testClass)
{
fixed (Vector128<Int16>* pFld = &_fld)
{
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(pFld)),
1
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<Int16>>() / sizeof(Int16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<SByte>>() / sizeof(SByte);
private static readonly byte Imm = 1;
private static Int16[] _data = new Int16[Op1ElementCount];
private static Vector128<Int16> _clsVar;
private Vector128<Int16> _fld;
private DataTable _dataTable;
static ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1()
{
for (var i = 0; i < Op1ElementCount; i++) { _data[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar), ref Unsafe.As<Int16, byte>(ref _data[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
}
public ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _fld), ref Unsafe.As<Int16, byte>(ref _data[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data[i] = TestLibrary.Generator.GetInt16(); }
_dataTable = new DataTable(_data, new SByte[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(_dataTable.inArrayPtr)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightArithmeticNarrowingSaturateLower), new Type[] { typeof(Vector128<Int16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<SByte>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightArithmeticNarrowingSaturateLower), new Type[] { typeof(Vector128<Int16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int16*)(_dataTable.inArrayPtr)),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<SByte>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
_clsVar,
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<Int16>* pClsVar = &_clsVar)
{
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(pClsVar)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var firstOp = Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr);
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(firstOp, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var firstOp = AdvSimd.LoadVector128((Int16*)(_dataTable.inArrayPtr));
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(firstOp, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1();
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(test._fld, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1();
fixed (Vector128<Int16>* pFld = &test._fld)
{
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(pFld)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(_fld, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<Int16>* pFld = &_fld)
{
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(pFld)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(test._fld, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(&test._fld)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<Int16> firstOp, void* result, [CallerMemberName] string method = "")
{
Int16[] inArray = new Int16[Op1ElementCount];
SByte[] outArray = new SByte[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Int16, byte>(ref inArray[0]), firstOp);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<SByte>>());
ValidateResult(inArray, outArray, method);
}
private void ValidateResult(void* firstOp, void* result, [CallerMemberName] string method = "")
{
Int16[] inArray = new Int16[Op1ElementCount];
SByte[] outArray = new SByte[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), (uint)Unsafe.SizeOf<Vector128<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<SByte>>());
ValidateResult(inArray, outArray, method);
}
private void ValidateResult(Int16[] firstOp, SByte[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.ShiftRightArithmeticNarrowingSaturate(firstOp[i], Imm) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightArithmeticNarrowingSaturateLower)}<SByte>(Vector128<Int16>, 1): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1()
{
var test = new ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1
{
private struct DataTable
{
private byte[] inArray;
private byte[] outArray;
private GCHandle inHandle;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Int16[] inArray, SByte[] outArray, int alignment)
{
int sizeOfinArray = inArray.Length * Unsafe.SizeOf<Int16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<SByte>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle = GCHandle.Alloc(this.inArray, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArrayPtr), ref Unsafe.As<Int16, byte>(ref inArray[0]), (uint)sizeOfinArray);
}
public void* inArrayPtr => Align((byte*)(inHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<Int16> _fld;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref testStruct._fld), ref Unsafe.As<Int16, byte>(ref _data[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
return testStruct;
}
public void RunStructFldScenario(ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1 testClass)
{
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(_fld, 1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1 testClass)
{
fixed (Vector128<Int16>* pFld = &_fld)
{
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(pFld)),
1
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<Int16>>() / sizeof(Int16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<SByte>>() / sizeof(SByte);
private static readonly byte Imm = 1;
private static Int16[] _data = new Int16[Op1ElementCount];
private static Vector128<Int16> _clsVar;
private Vector128<Int16> _fld;
private DataTable _dataTable;
static ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1()
{
for (var i = 0; i < Op1ElementCount; i++) { _data[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar), ref Unsafe.As<Int16, byte>(ref _data[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
}
public ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _fld), ref Unsafe.As<Int16, byte>(ref _data[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data[i] = TestLibrary.Generator.GetInt16(); }
_dataTable = new DataTable(_data, new SByte[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(_dataTable.inArrayPtr)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightArithmeticNarrowingSaturateLower), new Type[] { typeof(Vector128<Int16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<SByte>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightArithmeticNarrowingSaturateLower), new Type[] { typeof(Vector128<Int16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int16*)(_dataTable.inArrayPtr)),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<SByte>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
_clsVar,
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<Int16>* pClsVar = &_clsVar)
{
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(pClsVar)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var firstOp = Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr);
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(firstOp, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var firstOp = AdvSimd.LoadVector128((Int16*)(_dataTable.inArrayPtr));
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(firstOp, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1();
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(test._fld, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new ImmUnaryOpTest__ShiftRightArithmeticNarrowingSaturateLower_Vector64_SByte_1();
fixed (Vector128<Int16>* pFld = &test._fld)
{
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(pFld)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(_fld, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<Int16>* pFld = &_fld)
{
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(pFld)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(test._fld, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(
AdvSimd.LoadVector128((Int16*)(&test._fld)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<Int16> firstOp, void* result, [CallerMemberName] string method = "")
{
Int16[] inArray = new Int16[Op1ElementCount];
SByte[] outArray = new SByte[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Int16, byte>(ref inArray[0]), firstOp);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<SByte>>());
ValidateResult(inArray, outArray, method);
}
private void ValidateResult(void* firstOp, void* result, [CallerMemberName] string method = "")
{
Int16[] inArray = new Int16[Op1ElementCount];
SByte[] outArray = new SByte[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), (uint)Unsafe.SizeOf<Vector128<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<SByte>>());
ValidateResult(inArray, outArray, method);
}
private void ValidateResult(Int16[] firstOp, SByte[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.ShiftRightArithmeticNarrowingSaturate(firstOp[i], Imm) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightArithmeticNarrowingSaturateLower)}<SByte>(Vector128<Int16>, 1): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Speech/src/Internal/SrgsCompiler/OneOf.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#region Using directives
using System.Speech.Internal.SrgsParser;
#endregion
namespace System.Speech.Internal.SrgsCompiler
{
internal class OneOf : ParseElementCollection, IOneOf
{
#region Constructors
/// <summary>
/// Process the 'one-of' element.
/// </summary>
public OneOf(Rule rule, Backend backend)
: base(backend, rule)
{
// Create a start and end start.
_startState = _backend.CreateNewState(rule);
_endState = _backend.CreateNewState(rule);
//Add before the start state an epsilon arc
_startArc = _backend.EpsilonTransition(1.0f);
_startArc.End = _startState;
//Add after the end state an epsilon arc
_endArc = _backend.EpsilonTransition(1.0f);
_endArc.Start = _endState;
}
#endregion
#region Internal Method
/// <summary>
/// Process the '/one-of' element.
/// Connects all the arcs into an exit end point.
///
/// Verify OneOf contains at least one child 'item'.
/// </summary>
void IElement.PostParse(IElement parentElement)
{
if (_startArc.End.OutArcs.IsEmpty)
{
XmlParser.ThrowSrgsException(SRID.EmptyOneOf);
}
// Remove the extraneous arc and state if possible at the start and end
_startArc = TrimStart(_startArc, _backend);
_endArc = TrimEnd(_endArc, _backend);
// Connect the one-of to the parent
base.PostParse((ParseElementCollection)parentElement);
}
#endregion
#region Protected Method
/// <summary>
/// Adds a new arc to the one-of
/// </summary>
internal override void AddArc(Arc start, Arc end)
{
start = TrimStart(start, _backend);
end = TrimEnd(end, _backend);
State endStartState = end.Start;
State startEndState = start.End;
// Connect the previous arc with the 'start' set the insertion point
if (start.IsEpsilonTransition & start.IsPropertylessTransition && startEndState != null && startEndState.InArcs.IsEmpty)
{
System.Diagnostics.Debug.Assert(start.End == startEndState);
start.End = null;
_backend.MoveOutputTransitionsAndDeleteState(startEndState, _startState);
}
else
{
start.Start = _startState;
}
// Connect with the epsilon transition at the end
if (end.IsEpsilonTransition & end.IsPropertylessTransition && endStartState != null && endStartState.OutArcs.IsEmpty)
{
System.Diagnostics.Debug.Assert(end.Start == endStartState);
end.Start = null;
_backend.MoveInputTransitionsAndDeleteState(endStartState, _endState);
}
else
{
end.End = _endState;
}
}
#endregion
#region Protected Method
private State _startState;
private State _endState;
#endregion
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#region Using directives
using System.Speech.Internal.SrgsParser;
#endregion
namespace System.Speech.Internal.SrgsCompiler
{
internal class OneOf : ParseElementCollection, IOneOf
{
#region Constructors
/// <summary>
/// Process the 'one-of' element.
/// </summary>
public OneOf(Rule rule, Backend backend)
: base(backend, rule)
{
// Create a start and end start.
_startState = _backend.CreateNewState(rule);
_endState = _backend.CreateNewState(rule);
//Add before the start state an epsilon arc
_startArc = _backend.EpsilonTransition(1.0f);
_startArc.End = _startState;
//Add after the end state an epsilon arc
_endArc = _backend.EpsilonTransition(1.0f);
_endArc.Start = _endState;
}
#endregion
#region Internal Method
/// <summary>
/// Process the '/one-of' element.
/// Connects all the arcs into an exit end point.
///
/// Verify OneOf contains at least one child 'item'.
/// </summary>
void IElement.PostParse(IElement parentElement)
{
if (_startArc.End.OutArcs.IsEmpty)
{
XmlParser.ThrowSrgsException(SRID.EmptyOneOf);
}
// Remove the extraneous arc and state if possible at the start and end
_startArc = TrimStart(_startArc, _backend);
_endArc = TrimEnd(_endArc, _backend);
// Connect the one-of to the parent
base.PostParse((ParseElementCollection)parentElement);
}
#endregion
#region Protected Method
/// <summary>
/// Adds a new arc to the one-of
/// </summary>
internal override void AddArc(Arc start, Arc end)
{
start = TrimStart(start, _backend);
end = TrimEnd(end, _backend);
State endStartState = end.Start;
State startEndState = start.End;
// Connect the previous arc with the 'start' set the insertion point
if (start.IsEpsilonTransition & start.IsPropertylessTransition && startEndState != null && startEndState.InArcs.IsEmpty)
{
System.Diagnostics.Debug.Assert(start.End == startEndState);
start.End = null;
_backend.MoveOutputTransitionsAndDeleteState(startEndState, _startState);
}
else
{
start.Start = _startState;
}
// Connect with the epsilon transition at the end
if (end.IsEpsilonTransition & end.IsPropertylessTransition && endStartState != null && endStartState.OutArcs.IsEmpty)
{
System.Diagnostics.Debug.Assert(end.Start == endStartState);
end.Start = null;
_backend.MoveInputTransitionsAndDeleteState(endStartState, _endState);
}
else
{
end.End = _endState;
}
}
#endregion
#region Protected Method
private State _startState;
private State _endState;
#endregion
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/baseservices/exceptions/stacktrace/Tier1StackTrace.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Threading;
internal static class Program
{
private static int Main()
{
const int Pass = 100, Fail = 1;
string tier0StackTrace = Capture(true);
PromoteToTier1(() => Capture(false));
string tier1StackTrace = Capture(true);
return tier0StackTrace == tier1StackTrace ? Pass : Fail;
}
private static void PromoteToTier1(Action action)
{
// Call the method once to register a call for call counting
action();
// Allow time for call counting to begin
Thread.Sleep(500);
// Call the method enough times to trigger tier 1 promotion
for (int i = 0; i < 100; i++)
{
action();
}
// Allow time for the method to be jitted at tier 1
Thread.Sleep(500);
}
[MethodImpl(MethodImplOptions.NoInlining)]
private static string Capture(bool doWork)
{
if (!doWork)
{
return null;
}
string stackTrace = new StackTrace(true).ToString().Trim();
// Remove the last line of the stack trace, which would correspond with Main()
int lastNewLineIndex = stackTrace.LastIndexOf('\n');
if (lastNewLineIndex == -1)
{
return null;
}
return stackTrace.Substring(0, lastNewLineIndex).Trim();
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Threading;
internal static class Program
{
private static int Main()
{
const int Pass = 100, Fail = 1;
string tier0StackTrace = Capture(true);
PromoteToTier1(() => Capture(false));
string tier1StackTrace = Capture(true);
return tier0StackTrace == tier1StackTrace ? Pass : Fail;
}
private static void PromoteToTier1(Action action)
{
// Call the method once to register a call for call counting
action();
// Allow time for call counting to begin
Thread.Sleep(500);
// Call the method enough times to trigger tier 1 promotion
for (int i = 0; i < 100; i++)
{
action();
}
// Allow time for the method to be jitted at tier 1
Thread.Sleep(500);
}
[MethodImpl(MethodImplOptions.NoInlining)]
private static string Capture(bool doWork)
{
if (!doWork)
{
return null;
}
string stackTrace = new StackTrace(true).ToString().Trim();
// Remove the last line of the stack trace, which would correspond with Main()
int lastNewLineIndex = stackTrace.LastIndexOf('\n');
if (lastNewLineIndex == -1)
{
return null;
}
return stackTrace.Substring(0, lastNewLineIndex).Trim();
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/And.Vector64.Single.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void And_Vector64_Single()
{
var test = new SimpleBinaryOpTest__And_Vector64_Single();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class SimpleBinaryOpTest__And_Vector64_Single
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle2;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Single[] inArray1, Single[] inArray2, Single[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Single>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<Single>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Single>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Single, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<Single, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<Single> _fld1;
public Vector64<Single> _fld2;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref testStruct._fld1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref testStruct._fld2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
return testStruct;
}
public void RunStructFldScenario(SimpleBinaryOpTest__And_Vector64_Single testClass)
{
var result = AdvSimd.And(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleBinaryOpTest__And_Vector64_Single testClass)
{
fixed (Vector64<Single>* pFld1 = &_fld1)
fixed (Vector64<Single>* pFld2 = &_fld2)
{
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(pFld1)),
AdvSimd.LoadVector64((Single*)(pFld2))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 8;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<Single>>() / sizeof(Single);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector64<Single>>() / sizeof(Single);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<Single>>() / sizeof(Single);
private static Single[] _data1 = new Single[Op1ElementCount];
private static Single[] _data2 = new Single[Op2ElementCount];
private static Vector64<Single> _clsVar1;
private static Vector64<Single> _clsVar2;
private Vector64<Single> _fld1;
private Vector64<Single> _fld2;
private DataTable _dataTable;
static SimpleBinaryOpTest__And_Vector64_Single()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
}
public SimpleBinaryOpTest__And_Vector64_Single()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _fld1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _fld2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSingle(); }
_dataTable = new DataTable(_data1, _data2, new Single[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.And(
Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Single>>(_dataTable.inArray2Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Single*)(_dataTable.inArray2Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.And), new Type[] { typeof(Vector64<Single>), typeof(Vector64<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Single>>(_dataTable.inArray2Ptr)
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Single>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.And), new Type[] { typeof(Vector64<Single>), typeof(Vector64<Single>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Single*)(_dataTable.inArray2Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Single>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.And(
_clsVar1,
_clsVar2
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector64<Single>* pClsVar1 = &_clsVar1)
fixed (Vector64<Single>* pClsVar2 = &_clsVar2)
{
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(pClsVar1)),
AdvSimd.LoadVector64((Single*)(pClsVar2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<Single>>(_dataTable.inArray2Ptr);
var result = AdvSimd.And(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector64((Single*)(_dataTable.inArray2Ptr));
var result = AdvSimd.And(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleBinaryOpTest__And_Vector64_Single();
var result = AdvSimd.And(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleBinaryOpTest__And_Vector64_Single();
fixed (Vector64<Single>* pFld1 = &test._fld1)
fixed (Vector64<Single>* pFld2 = &test._fld2)
{
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(pFld1)),
AdvSimd.LoadVector64((Single*)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.And(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector64<Single>* pFld1 = &_fld1)
fixed (Vector64<Single>* pFld2 = &_fld2)
{
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(pFld1)),
AdvSimd.LoadVector64((Single*)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.And(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(&test._fld1)),
AdvSimd.LoadVector64((Single*)(&test._fld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector64<Single> op1, Vector64<Single> op2, void* result, [CallerMemberName] string method = "")
{
Single[] inArray1 = new Single[Op1ElementCount];
Single[] inArray2 = new Single[Op2ElementCount];
Single[] outArray = new Single[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<Single, byte>(ref inArray2[0]), op2);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Single>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(void* op1, void* op2, void* result, [CallerMemberName] string method = "")
{
Single[] inArray1 = new Single[Op1ElementCount];
Single[] inArray2 = new Single[Op2ElementCount];
Single[] outArray = new Single[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<Vector64<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Single>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (BitConverter.SingleToInt32Bits(Helpers.And(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i]))
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.And)}<Single>(Vector64<Single>, Vector64<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void And_Vector64_Single()
{
var test = new SimpleBinaryOpTest__And_Vector64_Single();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class SimpleBinaryOpTest__And_Vector64_Single
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle2;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Single[] inArray1, Single[] inArray2, Single[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Single>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<Single>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Single>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Single, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<Single, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<Single> _fld1;
public Vector64<Single> _fld2;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref testStruct._fld1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref testStruct._fld2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
return testStruct;
}
public void RunStructFldScenario(SimpleBinaryOpTest__And_Vector64_Single testClass)
{
var result = AdvSimd.And(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleBinaryOpTest__And_Vector64_Single testClass)
{
fixed (Vector64<Single>* pFld1 = &_fld1)
fixed (Vector64<Single>* pFld2 = &_fld2)
{
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(pFld1)),
AdvSimd.LoadVector64((Single*)(pFld2))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 8;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<Single>>() / sizeof(Single);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector64<Single>>() / sizeof(Single);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<Single>>() / sizeof(Single);
private static Single[] _data1 = new Single[Op1ElementCount];
private static Single[] _data2 = new Single[Op2ElementCount];
private static Vector64<Single> _clsVar1;
private static Vector64<Single> _clsVar2;
private Vector64<Single> _fld1;
private Vector64<Single> _fld2;
private DataTable _dataTable;
static SimpleBinaryOpTest__And_Vector64_Single()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
}
public SimpleBinaryOpTest__And_Vector64_Single()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _fld1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Single>, byte>(ref _fld2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Single>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetSingle(); }
_dataTable = new DataTable(_data1, _data2, new Single[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.And(
Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Single>>(_dataTable.inArray2Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Single*)(_dataTable.inArray2Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.And), new Type[] { typeof(Vector64<Single>), typeof(Vector64<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Single>>(_dataTable.inArray2Ptr)
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Single>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.And), new Type[] { typeof(Vector64<Single>), typeof(Vector64<Single>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Single*)(_dataTable.inArray2Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Single>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.And(
_clsVar1,
_clsVar2
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector64<Single>* pClsVar1 = &_clsVar1)
fixed (Vector64<Single>* pClsVar2 = &_clsVar2)
{
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(pClsVar1)),
AdvSimd.LoadVector64((Single*)(pClsVar2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<Single>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<Single>>(_dataTable.inArray2Ptr);
var result = AdvSimd.And(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector64((Single*)(_dataTable.inArray2Ptr));
var result = AdvSimd.And(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleBinaryOpTest__And_Vector64_Single();
var result = AdvSimd.And(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleBinaryOpTest__And_Vector64_Single();
fixed (Vector64<Single>* pFld1 = &test._fld1)
fixed (Vector64<Single>* pFld2 = &test._fld2)
{
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(pFld1)),
AdvSimd.LoadVector64((Single*)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.And(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector64<Single>* pFld1 = &_fld1)
fixed (Vector64<Single>* pFld2 = &_fld2)
{
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(pFld1)),
AdvSimd.LoadVector64((Single*)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.And(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.And(
AdvSimd.LoadVector64((Single*)(&test._fld1)),
AdvSimd.LoadVector64((Single*)(&test._fld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector64<Single> op1, Vector64<Single> op2, void* result, [CallerMemberName] string method = "")
{
Single[] inArray1 = new Single[Op1ElementCount];
Single[] inArray2 = new Single[Op2ElementCount];
Single[] outArray = new Single[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<Single, byte>(ref inArray2[0]), op2);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Single>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(void* op1, void* op2, void* result, [CallerMemberName] string method = "")
{
Single[] inArray1 = new Single[Op1ElementCount];
Single[] inArray2 = new Single[Op2ElementCount];
Single[] outArray = new Single[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<Vector64<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Single>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (BitConverter.SingleToInt32Bits(Helpers.And(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i]))
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.And)}<Single>(Vector64<Single>, Vector64<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd.Arm64/InsertSelectedScalar.Vector64.UInt16.3.Vector64.UInt16.3.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3()
{
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray3;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle3;
private GCHandle outHandle;
private ulong alignment;
public DataTable(UInt16[] inArray1, UInt16[] inArray3, UInt16[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<UInt16>();
int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<UInt16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<UInt16>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray3 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<UInt16, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<UInt16, byte>(ref inArray3[0]), (uint)sizeOfinArray3);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle3.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<UInt16> _fld1;
public Vector64<UInt16> _fld3;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref testStruct._fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref testStruct._fld3), ref Unsafe.As<UInt16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
return testStruct;
}
public void RunStructFldScenario(InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3 testClass)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(_fld1, 3, _fld3, 3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3 testClass)
{
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector64<UInt16>* pFld2 = &_fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)pFld1),
3,
AdvSimd.LoadVector64((UInt16*)pFld2),
3
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 8;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly int Op3ElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly byte ElementIndex1 = 3;
private static readonly byte ElementIndex2 = 3;
private static UInt16[] _data1 = new UInt16[Op1ElementCount];
private static UInt16[] _data3 = new UInt16[Op3ElementCount];
private static Vector64<UInt16> _clsVar1;
private static Vector64<UInt16> _clsVar3;
private Vector64<UInt16> _fld1;
private Vector64<UInt16> _fld3;
private DataTable _dataTable;
static InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar3), ref Unsafe.As<UInt16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
}
public InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _fld3), ref Unsafe.As<UInt16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt16(); }
_dataTable = new DataTable(_data1, _data3, new UInt16[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.Arm64.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.Arm64.InsertSelectedScalar(
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
3,
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray3Ptr),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
3,
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray3Ptr)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.InsertSelectedScalar), new Type[] { typeof(Vector64<UInt16>), typeof(byte), typeof(Vector64<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
ElementIndex1,
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray3Ptr),
ElementIndex2
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.InsertSelectedScalar), new Type[] { typeof(Vector64<UInt16>), typeof(byte), typeof(Vector64<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
ElementIndex1,
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray3Ptr)),
ElementIndex2
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.Arm64.InsertSelectedScalar(
_clsVar1,
3,
_clsVar3,
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector64<UInt16>* pClsVar1 = &_clsVar1)
fixed (Vector64<UInt16>* pClsVar3 = &_clsVar3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)(pClsVar1)),
3,
AdvSimd.LoadVector64((UInt16*)(pClsVar3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr);
var op3 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray3Ptr);
var result = AdvSimd.Arm64.InsertSelectedScalar(op1, 3, op3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op3, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr));
var op3 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray3Ptr));
var result = AdvSimd.Arm64.InsertSelectedScalar(op1, 3, op3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3();
var result = AdvSimd.Arm64.InsertSelectedScalar(test._fld1, 3, test._fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3();
fixed (Vector64<UInt16>* pFld1 = &test._fld1)
fixed (Vector64<UInt16>* pFld2 = &test._fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)pFld1),
3,
AdvSimd.LoadVector64((UInt16*)pFld2),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.Arm64.InsertSelectedScalar(_fld1, 3, _fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector64<UInt16>* pFld2 = &_fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)pFld1),
3,
AdvSimd.LoadVector64((UInt16*)pFld2),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.InsertSelectedScalar(test._fld1, 3, test._fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)(&test._fld1)),
3,
AdvSimd.LoadVector64((UInt16*)(&test._fld3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector64<UInt16> op1, Vector64<UInt16> op3, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] inArray3 = new UInt16[Op3ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray3[0]), op3);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, inArray3, outArray, method);
}
private void ValidateResult(void* op1, void* op3, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] inArray3 = new UInt16[Op3ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, inArray3, outArray, method);
}
private void ValidateResult(UInt16[] firstOp, UInt16[] thirdOp, UInt16[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.Insert(firstOp, ElementIndex1, thirdOp[ElementIndex2], i) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd.Arm64)}.{nameof(AdvSimd.Arm64.InsertSelectedScalar)}<UInt16>(Vector64<UInt16>, {3}, Vector64<UInt16>, {3}): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3()
{
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray3;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle3;
private GCHandle outHandle;
private ulong alignment;
public DataTable(UInt16[] inArray1, UInt16[] inArray3, UInt16[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<UInt16>();
int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<UInt16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<UInt16>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray3 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<UInt16, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<UInt16, byte>(ref inArray3[0]), (uint)sizeOfinArray3);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle3.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<UInt16> _fld1;
public Vector64<UInt16> _fld3;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref testStruct._fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref testStruct._fld3), ref Unsafe.As<UInt16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
return testStruct;
}
public void RunStructFldScenario(InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3 testClass)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(_fld1, 3, _fld3, 3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3 testClass)
{
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector64<UInt16>* pFld2 = &_fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)pFld1),
3,
AdvSimd.LoadVector64((UInt16*)pFld2),
3
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 8;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly int Op3ElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly byte ElementIndex1 = 3;
private static readonly byte ElementIndex2 = 3;
private static UInt16[] _data1 = new UInt16[Op1ElementCount];
private static UInt16[] _data3 = new UInt16[Op3ElementCount];
private static Vector64<UInt16> _clsVar1;
private static Vector64<UInt16> _clsVar3;
private Vector64<UInt16> _fld1;
private Vector64<UInt16> _fld3;
private DataTable _dataTable;
static InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar3), ref Unsafe.As<UInt16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
}
public InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _fld3), ref Unsafe.As<UInt16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt16(); }
_dataTable = new DataTable(_data1, _data3, new UInt16[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.Arm64.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.Arm64.InsertSelectedScalar(
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
3,
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray3Ptr),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
3,
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray3Ptr)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.InsertSelectedScalar), new Type[] { typeof(Vector64<UInt16>), typeof(byte), typeof(Vector64<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
ElementIndex1,
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray3Ptr),
ElementIndex2
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.InsertSelectedScalar), new Type[] { typeof(Vector64<UInt16>), typeof(byte), typeof(Vector64<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
ElementIndex1,
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray3Ptr)),
ElementIndex2
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.Arm64.InsertSelectedScalar(
_clsVar1,
3,
_clsVar3,
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector64<UInt16>* pClsVar1 = &_clsVar1)
fixed (Vector64<UInt16>* pClsVar3 = &_clsVar3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)(pClsVar1)),
3,
AdvSimd.LoadVector64((UInt16*)(pClsVar3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr);
var op3 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray3Ptr);
var result = AdvSimd.Arm64.InsertSelectedScalar(op1, 3, op3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op3, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr));
var op3 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray3Ptr));
var result = AdvSimd.Arm64.InsertSelectedScalar(op1, 3, op3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3();
var result = AdvSimd.Arm64.InsertSelectedScalar(test._fld1, 3, test._fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector64_UInt16_3_Vector64_UInt16_3();
fixed (Vector64<UInt16>* pFld1 = &test._fld1)
fixed (Vector64<UInt16>* pFld2 = &test._fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)pFld1),
3,
AdvSimd.LoadVector64((UInt16*)pFld2),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.Arm64.InsertSelectedScalar(_fld1, 3, _fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector64<UInt16>* pFld2 = &_fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)pFld1),
3,
AdvSimd.LoadVector64((UInt16*)pFld2),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.InsertSelectedScalar(test._fld1, 3, test._fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector64((UInt16*)(&test._fld1)),
3,
AdvSimd.LoadVector64((UInt16*)(&test._fld3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector64<UInt16> op1, Vector64<UInt16> op3, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] inArray3 = new UInt16[Op3ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray3[0]), op3);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, inArray3, outArray, method);
}
private void ValidateResult(void* op1, void* op3, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] inArray3 = new UInt16[Op3ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, inArray3, outArray, method);
}
private void ValidateResult(UInt16[] firstOp, UInt16[] thirdOp, UInt16[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.Insert(firstOp, ElementIndex1, thirdOp[ElementIndex2], i) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd.Arm64)}.{nameof(AdvSimd.Arm64.InsertSelectedScalar)}<UInt16>(Vector64<UInt16>, {3}, Vector64<UInt16>, {3}): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/jit64/valuetypes/nullable/box-unbox/interface/box-unbox-interface002.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>PdbOnly</DebugType>
</PropertyGroup>
<ItemGroup>
<Compile Include="box-unbox-interface002.cs" />
<Compile Include="..\structdef.cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>PdbOnly</DebugType>
</PropertyGroup>
<ItemGroup>
<Compile Include="box-unbox-interface002.cs" />
<Compile Include="..\structdef.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Data.Odbc/src/System/Data/Odbc/OdbcMetaDataFactory.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.IO;
using System.Data.Common;
using System.Data.ProviderBase;
using System.Diagnostics;
using System.Text;
namespace System.Data.Odbc
{
internal sealed class OdbcMetaDataFactory : DbMetaDataFactory
{
private readonly struct SchemaFunctionName
{
internal SchemaFunctionName(string schemaName, ODBC32.SQL_API odbcFunction)
{
_schemaName = schemaName;
_odbcFunction = odbcFunction;
}
internal readonly string _schemaName;
internal readonly ODBC32.SQL_API _odbcFunction;
}
private const string _collectionName = "CollectionName";
private const string _populationMechanism = "PopulationMechanism";
private const string _prepareCollection = "PrepareCollection";
private readonly SchemaFunctionName[] _schemaMapping;
internal static readonly char[] KeywordSeparatorChar = new char[1] { ',' };
internal OdbcMetaDataFactory(Stream XMLStream,
string serverVersion,
string serverVersionNormalized,
OdbcConnection connection) :
base(XMLStream, serverVersion, serverVersionNormalized)
{
// set up the colletion name ODBC function mapping guid mapping
_schemaMapping = new SchemaFunctionName[] {
new SchemaFunctionName(DbMetaDataCollectionNames.DataTypes, ODBC32.SQL_API.SQLGETTYPEINFO),
new SchemaFunctionName(OdbcMetaDataCollectionNames.Columns, ODBC32.SQL_API.SQLCOLUMNS),
new SchemaFunctionName(OdbcMetaDataCollectionNames.Indexes, ODBC32.SQL_API.SQLSTATISTICS),
new SchemaFunctionName(OdbcMetaDataCollectionNames.Procedures, ODBC32.SQL_API.SQLPROCEDURES),
new SchemaFunctionName(OdbcMetaDataCollectionNames.ProcedureColumns, ODBC32.SQL_API.SQLPROCEDURECOLUMNS),
new SchemaFunctionName(OdbcMetaDataCollectionNames.ProcedureParameters, ODBC32.SQL_API.SQLPROCEDURECOLUMNS),
new SchemaFunctionName(OdbcMetaDataCollectionNames.Tables, ODBC32.SQL_API.SQLTABLES),
new SchemaFunctionName(OdbcMetaDataCollectionNames.Views, ODBC32.SQL_API.SQLTABLES)};
// verify the existance of the table in the data set
DataTable? metaDataCollectionsTable = CollectionDataSet.Tables[DbMetaDataCollectionNames.MetaDataCollections];
if (metaDataCollectionsTable == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.MetaDataCollections);
}
// copy the table filtering out any rows that don't apply to the current version of the provider
metaDataCollectionsTable = CloneAndFilterCollection(DbMetaDataCollectionNames.MetaDataCollections, null);
// verify the existance of the table in the data set
DataTable? restrictionsTable = CollectionDataSet.Tables[DbMetaDataCollectionNames.Restrictions];
if (restrictionsTable != null)
{
// copy the table filtering out any rows that don't apply to the current version of the provider
restrictionsTable = CloneAndFilterCollection(DbMetaDataCollectionNames.Restrictions, null);
}
// need to filter out any of the collections where
// 1) it is populated using prepare collection
// 2) it is in the collection to odbc function mapping above
// 3) the provider does not support the necessary odbc function
DataColumn populationMechanism = metaDataCollectionsTable.Columns[_populationMechanism]!;
DataColumn collectionName = metaDataCollectionsTable.Columns[_collectionName]!;
DataColumn? restrictionCollectionName = null;
if (restrictionsTable != null)
{
restrictionCollectionName = restrictionsTable.Columns[_collectionName];
}
Debug.Assert(restrictionCollectionName != null);
foreach (DataRow collection in metaDataCollectionsTable.Rows)
{
if ((string)collection[populationMechanism] == _prepareCollection)
{
// is the collection in the mapping
int mapping = -1;
for (int i = 0; i < _schemaMapping.Length; i++)
{
if (_schemaMapping[i]._schemaName == (string)collection[collectionName])
{
mapping = i;
break;
}
}
// no go on to the next collection
if (mapping == -1)
{
continue;
}
// does the provider support the necessary odbc function
// if not delete the row from the table
if (connection.SQLGetFunctions(_schemaMapping[mapping]._odbcFunction) == false)
{
// but first delete any related restrictions
if (restrictionsTable != null)
{
foreach (DataRow restriction in restrictionsTable.Rows)
{
if ((string)collection[collectionName] == (string)restriction[restrictionCollectionName])
{
restriction.Delete();
}
}
restrictionsTable.AcceptChanges();
}
collection.Delete();
}
}
}
// replace the original table with the updated one
metaDataCollectionsTable.AcceptChanges();
CollectionDataSet.Tables.Remove(CollectionDataSet.Tables[DbMetaDataCollectionNames.MetaDataCollections]!);
CollectionDataSet.Tables.Add(metaDataCollectionsTable);
if (restrictionsTable != null)
{
CollectionDataSet.Tables.Remove(CollectionDataSet.Tables[DbMetaDataCollectionNames.Restrictions]!);
CollectionDataSet.Tables.Add(restrictionsTable);
}
}
private object BooleanFromODBC(object odbcSource)
{
if (odbcSource != DBNull.Value)
{
//convert to Int32 before doing the comparison
//some odbc drivers report the odbcSource value as unsigned, in which case we will
//have upgraded the type to Int32, and thus can't cast directly to short
if (Convert.ToInt32(odbcSource, null) == 0)
{
return false;
}
else
{
return true;
}
}
return DBNull.Value;
}
private OdbcCommand GetCommand(OdbcConnection connection)
{
OdbcCommand command = connection.CreateCommand();
// You need to make sure you pick up the transaction from the connection,
// or odd things can happen...
command.Transaction = connection.LocalTransaction;
return command;
}
private DataTable DataTableFromDataReader(IDataReader reader, string tableName)
{
// set up the column structure of the data table from the reader
object[] values;
DataTable resultTable = NewDataTableFromReader(reader, out values, tableName);
// populate the data table from the data reader
while (reader.Read())
{
reader.GetValues(values);
resultTable.Rows.Add(values);
}
return resultTable;
}
private void DataTableFromDataReaderDataTypes(DataTable dataTypesTable, OdbcDataReader dataReader, OdbcConnection connection)
{
DataTable? schemaTable;
//
// Build a DataTable from the reader
schemaTable = dataReader.GetSchemaTable();
// vstfdevdiv:479715 Handle cases where reader is empty
if (null == schemaTable)
{
throw ADP.OdbcNoTypesFromProvider();
}
object[] getTypeInfoValues = new object[schemaTable.Rows.Count];
DataRow dataTypesRow;
DataColumn typeNameColumn = dataTypesTable.Columns[DbMetaDataColumnNames.TypeName]!;
DataColumn providerDbTypeColumn = dataTypesTable.Columns[DbMetaDataColumnNames.ProviderDbType]!;
DataColumn columnSizeColumn = dataTypesTable.Columns[DbMetaDataColumnNames.ColumnSize]!;
DataColumn createParametersColumn = dataTypesTable.Columns[DbMetaDataColumnNames.CreateParameters]!;
DataColumn dataTypeColumn = dataTypesTable.Columns[DbMetaDataColumnNames.DataType]!;
DataColumn isAutoIncermentableColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsAutoIncrementable]!;
DataColumn isCaseSensitiveColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsCaseSensitive]!;
DataColumn isFixedLengthColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsFixedLength]!;
DataColumn isFixedPrecisionScaleColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsFixedPrecisionScale]!;
DataColumn isLongColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsLong]!;
DataColumn isNullableColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsNullable]!;
DataColumn isSearchableColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsSearchable]!;
DataColumn isSearchableWithLikeColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsSearchableWithLike]!;
DataColumn isUnsignedColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsUnsigned]!;
DataColumn maximumScaleColumn = dataTypesTable.Columns[DbMetaDataColumnNames.MaximumScale]!;
DataColumn minimumScaleColumn = dataTypesTable.Columns[DbMetaDataColumnNames.MinimumScale]!;
DataColumn literalPrefixColumn = dataTypesTable.Columns[DbMetaDataColumnNames.LiteralPrefix]!;
DataColumn literalSuffixColumn = dataTypesTable.Columns[DbMetaDataColumnNames.LiteralSuffix]!;
DataColumn SQLTypeNameColumn = dataTypesTable.Columns[OdbcMetaDataColumnNames.SQLType]!;
const int indexTYPE_NAME = 0;
const int indexDATA_TYPE = 1;
const int indexCOLUMN_SIZE = 2;
const int indexCREATE_PARAMS = 5;
const int indexAUTO_UNIQUE_VALUE = 11;
const int indexCASE_SENSITIVE = 7;
const int indexFIXED_PREC_SCALE = 10;
const int indexNULLABLE = 6;
const int indexSEARCHABLE = 8;
const int indexUNSIGNED_ATTRIBUTE = 9;
const int indexMAXIMUM_SCALE = 14;
const int indexMINIMUM_SCALE = 13;
const int indexLITERAL_PREFIX = 3;
const int indexLITERAL_SUFFIX = 4;
const int SQL_DATE_V2 = 9;
const int SQL_TIME_V2 = 10;
TypeMap? typeMap;
while (dataReader.Read())
{
dataReader.GetValues(getTypeInfoValues);
dataTypesRow = dataTypesTable.NewRow();
ODBC32.SQL_TYPE sqlType;
dataTypesRow[typeNameColumn] = getTypeInfoValues[indexTYPE_NAME];
dataTypesRow[SQLTypeNameColumn] = getTypeInfoValues[indexDATA_TYPE];
sqlType = (ODBC32.SQL_TYPE)(int)Convert.ChangeType(getTypeInfoValues[indexDATA_TYPE], typeof(int), null);
// if the driver is pre version 3 and it returned the v2 SQL_DATE or SQL_TIME types they need
// to be mapped to their v3 equivalent
if (connection.IsV3Driver == false)
{
if ((int)sqlType == SQL_DATE_V2)
{
sqlType = ODBC32.SQL_TYPE.TYPE_DATE;
}
else if ((int)sqlType == SQL_TIME_V2)
{
sqlType = ODBC32.SQL_TYPE.TYPE_TIME;
}
}
try
{
typeMap = TypeMap.FromSqlType(sqlType);
}
// FromSqlType will throw an argument exception if it does not recognize the SqlType.
// This is not an error since the GetTypeInfo DATA_TYPE may be a SQL data type or a driver specific
// type. If there is no TypeMap for the type its not an error but it will degrade our level of
// understanding of/ support for the type.
catch (ArgumentException)
{
typeMap = null;
}
// if we have a type map we can determine the dbType and the CLR type if not leave them null
if (typeMap != null)
{
dataTypesRow[providerDbTypeColumn] = typeMap._odbcType;
dataTypesRow[dataTypeColumn] = typeMap._type.FullName;
// setting isLong and isFixedLength only if we have a type map because for provider
// specific types we have no idea what the types attributes are if GetTypeInfo did not
// tell us
switch (sqlType)
{
case ODBC32.SQL_TYPE.LONGVARCHAR:
case ODBC32.SQL_TYPE.WLONGVARCHAR:
case ODBC32.SQL_TYPE.LONGVARBINARY:
case ODBC32.SQL_TYPE.SS_XML:
dataTypesRow[isLongColumn] = true;
dataTypesRow[isFixedLengthColumn] = false;
break;
case ODBC32.SQL_TYPE.VARCHAR:
case ODBC32.SQL_TYPE.WVARCHAR:
case ODBC32.SQL_TYPE.VARBINARY:
dataTypesRow[isLongColumn] = false;
dataTypesRow[isFixedLengthColumn] = false;
break;
case ODBC32.SQL_TYPE.CHAR:
case ODBC32.SQL_TYPE.WCHAR:
case ODBC32.SQL_TYPE.DECIMAL:
case ODBC32.SQL_TYPE.NUMERIC:
case ODBC32.SQL_TYPE.SMALLINT:
case ODBC32.SQL_TYPE.INTEGER:
case ODBC32.SQL_TYPE.REAL:
case ODBC32.SQL_TYPE.FLOAT:
case ODBC32.SQL_TYPE.DOUBLE:
case ODBC32.SQL_TYPE.BIT:
case ODBC32.SQL_TYPE.TINYINT:
case ODBC32.SQL_TYPE.BIGINT:
case ODBC32.SQL_TYPE.TYPE_DATE:
case ODBC32.SQL_TYPE.TYPE_TIME:
case ODBC32.SQL_TYPE.TIMESTAMP:
case ODBC32.SQL_TYPE.TYPE_TIMESTAMP:
case ODBC32.SQL_TYPE.GUID:
case ODBC32.SQL_TYPE.SS_VARIANT:
case ODBC32.SQL_TYPE.SS_UTCDATETIME:
case ODBC32.SQL_TYPE.SS_TIME_EX:
case ODBC32.SQL_TYPE.BINARY:
dataTypesRow[isLongColumn] = false;
dataTypesRow[isFixedLengthColumn] = true;
break;
case ODBC32.SQL_TYPE.SS_UDT:
default:
// for User defined types don't know if its long or if it is
// varaible length or not so leave the fields null
break;
}
}
dataTypesRow[columnSizeColumn] = getTypeInfoValues[indexCOLUMN_SIZE];
dataTypesRow[createParametersColumn] = getTypeInfoValues[indexCREATE_PARAMS];
if ((getTypeInfoValues[indexAUTO_UNIQUE_VALUE] == DBNull.Value) ||
(Convert.ToInt16(getTypeInfoValues[indexAUTO_UNIQUE_VALUE], null) == 0))
{
dataTypesRow[isAutoIncermentableColumn] = false;
}
else
{
dataTypesRow[isAutoIncermentableColumn] = true;
}
dataTypesRow[isCaseSensitiveColumn] = BooleanFromODBC(getTypeInfoValues[indexCASE_SENSITIVE]);
dataTypesRow[isFixedPrecisionScaleColumn] = BooleanFromODBC(getTypeInfoValues[indexFIXED_PREC_SCALE]);
if (getTypeInfoValues[indexNULLABLE] != DBNull.Value)
{
//Use Convert.ToInt16 instead of direct cast to short because the value will be Int32 in some cases
switch ((ODBC32.SQL_NULLABILITY)Convert.ToInt16(getTypeInfoValues[indexNULLABLE], null))
{
case ODBC32.SQL_NULLABILITY.NO_NULLS:
dataTypesRow[isNullableColumn] = false;
break;
case ODBC32.SQL_NULLABILITY.NULLABLE:
dataTypesRow[isNullableColumn] = true;
break;
case ODBC32.SQL_NULLABILITY.UNKNOWN:
dataTypesRow[isNullableColumn] = DBNull.Value;
break;
}
}
if (DBNull.Value != getTypeInfoValues[indexSEARCHABLE])
{
//Use Convert.ToInt16 instead of direct cast to short because the value will be Int32 in some cases
short searchableValue = Convert.ToInt16(getTypeInfoValues[indexSEARCHABLE], null);
switch (searchableValue)
{
case (short)ODBC32.SQL_SEARCHABLE.UNSEARCHABLE:
dataTypesRow[isSearchableColumn] = false;
dataTypesRow[isSearchableWithLikeColumn] = false;
break;
case (short)ODBC32.SQL_SEARCHABLE.LIKE_ONLY:
dataTypesRow[isSearchableColumn] = false;
dataTypesRow[isSearchableWithLikeColumn] = true;
break;
case (short)ODBC32.SQL_SEARCHABLE.ALL_EXCEPT_LIKE:
dataTypesRow[isSearchableColumn] = true;
dataTypesRow[isSearchableWithLikeColumn] = false;
break;
case (short)ODBC32.SQL_SEARCHABLE.SEARCHABLE:
dataTypesRow[isSearchableColumn] = true;
dataTypesRow[isSearchableWithLikeColumn] = true;
break;
}
}
dataTypesRow[isUnsignedColumn] = BooleanFromODBC(getTypeInfoValues[indexUNSIGNED_ATTRIBUTE]);
//For assignment to the DataSet, don't cast the data types -- let the DataSet take care of any conversion
if (getTypeInfoValues[indexMAXIMUM_SCALE] != DBNull.Value)
{
dataTypesRow[maximumScaleColumn] = getTypeInfoValues[indexMAXIMUM_SCALE];
}
if (getTypeInfoValues[indexMINIMUM_SCALE] != DBNull.Value)
{
dataTypesRow[minimumScaleColumn] = getTypeInfoValues[indexMINIMUM_SCALE];
}
if (getTypeInfoValues[indexLITERAL_PREFIX] != DBNull.Value)
{
dataTypesRow[literalPrefixColumn] = getTypeInfoValues[indexLITERAL_PREFIX];
}
if (getTypeInfoValues[indexLITERAL_SUFFIX] != DBNull.Value)
{
dataTypesRow[literalSuffixColumn] = getTypeInfoValues[indexLITERAL_SUFFIX];
}
dataTypesTable.Rows.Add(dataTypesRow);
}
}
private DataTable DataTableFromDataReaderIndex(IDataReader reader,
string tableName,
string? restrictionIndexName)
{
// set up the column structure of the data table from the reader
object[] values;
DataTable resultTable = NewDataTableFromReader(reader, out values, tableName);
// populate the data table from the data reader
int positionOfType = 6;
int positionOfIndexName = 5;
while (reader.Read())
{
reader.GetValues(values);
if (IncludeIndexRow(values[positionOfIndexName],
restrictionIndexName,
Convert.ToInt16(values[positionOfType], null)) == true)
{
resultTable.Rows.Add(values);
}
}
return resultTable;
}
private DataTable DataTableFromDataReaderProcedureColumns(IDataReader reader, string tableName, bool isColumn)
{
// set up the column structure of the data table from the reader
object[] values;
DataTable resultTable = NewDataTableFromReader(reader, out values, tableName);
// populate the data table from the data reader
int positionOfColumnType = 4;
while (reader.Read())
{
reader.GetValues(values);
// the column type should always be short but need to check just in case
if (values[positionOfColumnType].GetType() == typeof(short))
{
if ((((short)values[positionOfColumnType] == ODBC32.SQL_RESULT_COL) && (isColumn == true)) ||
(((short)values[positionOfColumnType] != ODBC32.SQL_RESULT_COL) && (isColumn == false)))
{
resultTable.Rows.Add(values);
}
}
}
return resultTable;
}
private DataTable DataTableFromDataReaderProcedures(IDataReader reader, string tableName, short procedureType)
{
// Build a DataTable from the reader
// set up the column structure of the data table from the reader
object[] values;
DataTable resultTable = NewDataTableFromReader(reader, out values, tableName);
// populate the data table from the data reader
int positionOfProcedureType = 7;
while (reader.Read())
{
reader.GetValues(values);
// the column type should always be short but need to check just in case its null
if (values[positionOfProcedureType].GetType() == typeof(short))
{
if ((short)values[positionOfProcedureType] == procedureType)
{
resultTable.Rows.Add(values);
}
}
}
return resultTable;
}
private void FillOutRestrictions(int restrictionsCount, string?[]? restrictions, object?[] allRestrictions, string collectionName)
{
Debug.Assert(allRestrictions.Length >= restrictionsCount);
int i = 0;
// if we have restrictions put them in the restrictions array
if (restrictions != null)
{
if (restrictions.Length > restrictionsCount)
{
throw ADP.TooManyRestrictions(collectionName);
}
for (i = 0; i < restrictions.Length; i++)
{
if (restrictions[i] != null)
{
allRestrictions[i] = restrictions[i];
}
}
}
// initalize the rest to no restrictions
for (; i < restrictionsCount; i++)
{
allRestrictions[i] = null;
}
}
private DataTable GetColumnsCollection(string?[]? restrictions, OdbcConnection connection)
{
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
DataTable? resultTable = null;
const int columnsRestrictionsCount = 4;
try
{
command = GetCommand(connection);
string[] allRestrictions = new string[columnsRestrictionsCount];
FillOutRestrictions(columnsRestrictionsCount, restrictions, allRestrictions, OdbcMetaDataCollectionNames.Columns);
dataReader = command.ExecuteReaderFromSQLMethod(allRestrictions, ODBC32.SQL_API.SQLCOLUMNS);
resultTable = DataTableFromDataReader(dataReader, OdbcMetaDataCollectionNames.Columns);
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
return resultTable;
}
private DataTable GetDataSourceInformationCollection(string?[]? restrictions,
OdbcConnection connection)
{
if (ADP.IsEmptyArray(restrictions) == false)
{
throw ADP.TooManyRestrictions(DbMetaDataCollectionNames.DataSourceInformation);
}
// verify that the data source information table is in the data set
DataTable? dataSourceInformationTable = CollectionDataSet.Tables[DbMetaDataCollectionNames.DataSourceInformation];
if (dataSourceInformationTable == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.DataSourceInformation);
}
// copy the table filtering out any rows that don't apply to the current version of the provider
dataSourceInformationTable = CloneAndFilterCollection(DbMetaDataCollectionNames.DataSourceInformation, null);
// after filtering there better be just one row
if (dataSourceInformationTable.Rows.Count != 1)
{
throw ADP.IncorrectNumberOfDataSourceInformationRows();
}
DataRow dataSourceInformation = dataSourceInformationTable.Rows[0];
string? stringValue;
short int16Value;
int int32Value;
ODBC32.SQLRETURN retcode;
// update the catalog separator
stringValue = connection.GetInfoStringUnhandled(ODBC32.SQL_INFO.CATALOG_NAME_SEPARATOR);
if (!string.IsNullOrEmpty(stringValue))
{
StringBuilder patternEscaped = new StringBuilder();
ADP.EscapeSpecialCharacters(stringValue, patternEscaped);
dataSourceInformation[DbMetaDataColumnNames.CompositeIdentifierSeparatorPattern] = patternEscaped.ToString();
}
// get the DBMS Name
stringValue = connection.GetInfoStringUnhandled(ODBC32.SQL_INFO.DBMS_NAME);
if (stringValue != null)
{
dataSourceInformation[DbMetaDataColumnNames.DataSourceProductName] = stringValue;
}
// update the server version strings
dataSourceInformation[DbMetaDataColumnNames.DataSourceProductVersion] = ServerVersion;
dataSourceInformation[DbMetaDataColumnNames.DataSourceProductVersionNormalized] = ServerVersionNormalized;
// values that are the same for all ODBC drivers. See bug 105333
dataSourceInformation[DbMetaDataColumnNames.ParameterMarkerFormat] = "?";
dataSourceInformation[DbMetaDataColumnNames.ParameterMarkerPattern] = "\\?";
dataSourceInformation[DbMetaDataColumnNames.ParameterNameMaxLength] = 0;
// determine the supportedJoinOperators
// leave the column null if the GetInfo fails. There is no explicit value for
// unknown.
if (connection.IsV3Driver)
{
retcode = connection.GetInfoInt32Unhandled(ODBC32.SQL_INFO.SQL_OJ_CAPABILITIES_30, out int32Value);
}
else
{
retcode = connection.GetInfoInt32Unhandled(ODBC32.SQL_INFO.SQL_OJ_CAPABILITIES_20, out int32Value);
}
if ((retcode == ODBC32.SQLRETURN.SUCCESS) || (retcode == ODBC32.SQLRETURN.SUCCESS_WITH_INFO))
{
Common.SupportedJoinOperators supportedJoinOperators = Common.SupportedJoinOperators.None;
if ((int32Value & (int)ODBC32.SQL_OJ_CAPABILITIES.LEFT) != 0)
{
supportedJoinOperators = supportedJoinOperators | Common.SupportedJoinOperators.LeftOuter;
}
if ((int32Value & (int)ODBC32.SQL_OJ_CAPABILITIES.RIGHT) != 0)
{
supportedJoinOperators = supportedJoinOperators | Common.SupportedJoinOperators.RightOuter;
}
if ((int32Value & (int)ODBC32.SQL_OJ_CAPABILITIES.FULL) != 0)
{
supportedJoinOperators = supportedJoinOperators | Common.SupportedJoinOperators.FullOuter;
}
if ((int32Value & (int)ODBC32.SQL_OJ_CAPABILITIES.INNER) != 0)
{
supportedJoinOperators = supportedJoinOperators | Common.SupportedJoinOperators.Inner;
}
dataSourceInformation[DbMetaDataColumnNames.SupportedJoinOperators] = supportedJoinOperators;
}
// determine the GroupByBehavior
retcode = connection.GetInfoInt16Unhandled(ODBC32.SQL_INFO.GROUP_BY, out int16Value);
Common.GroupByBehavior groupByBehavior = Common.GroupByBehavior.Unknown;
if ((retcode == ODBC32.SQLRETURN.SUCCESS) || (retcode == ODBC32.SQLRETURN.SUCCESS_WITH_INFO))
{
switch (int16Value)
{
case (short)ODBC32.SQL_GROUP_BY.NOT_SUPPORTED:
groupByBehavior = Common.GroupByBehavior.NotSupported;
break;
case (short)ODBC32.SQL_GROUP_BY.GROUP_BY_EQUALS_SELECT:
groupByBehavior = Common.GroupByBehavior.ExactMatch;
break;
case (short)ODBC32.SQL_GROUP_BY.GROUP_BY_CONTAINS_SELECT:
groupByBehavior = Common.GroupByBehavior.MustContainAll;
break;
case (short)ODBC32.SQL_GROUP_BY.NO_RELATION:
groupByBehavior = Common.GroupByBehavior.Unrelated;
break;
/* COLLATE is new in ODBC 3.0 and GroupByBehavior does not have a value for it.
case ODBC32.SQL_GROUP_BY.COLLATE:
groupByBehavior = Common.GroupByBehavior.Unknown;
break;
*/
}
}
dataSourceInformation[DbMetaDataColumnNames.GroupByBehavior] = groupByBehavior;
// determine the identifier case
retcode = connection.GetInfoInt16Unhandled(ODBC32.SQL_INFO.IDENTIFIER_CASE, out int16Value);
Common.IdentifierCase identifierCase = Common.IdentifierCase.Unknown;
if ((retcode == ODBC32.SQLRETURN.SUCCESS) || (retcode == ODBC32.SQLRETURN.SUCCESS_WITH_INFO))
{
switch (int16Value)
{
case (short)ODBC32.SQL_IDENTIFIER_CASE.SENSITIVE:
identifierCase = Common.IdentifierCase.Sensitive;
break;
case (short)ODBC32.SQL_IDENTIFIER_CASE.UPPER:
case (short)ODBC32.SQL_IDENTIFIER_CASE.LOWER:
case (short)ODBC32.SQL_IDENTIFIER_CASE.MIXED:
identifierCase = Common.IdentifierCase.Insensitive;
break;
}
}
dataSourceInformation[DbMetaDataColumnNames.IdentifierCase] = identifierCase;
// OrderByColumnsInSelect
stringValue = connection.GetInfoStringUnhandled(ODBC32.SQL_INFO.ORDER_BY_COLUMNS_IN_SELECT);
if (stringValue != null)
{
if (stringValue == "Y")
{
dataSourceInformation[DbMetaDataColumnNames.OrderByColumnsInSelect] = true;
}
else if (stringValue == "N")
{
dataSourceInformation[DbMetaDataColumnNames.OrderByColumnsInSelect] = false;
}
}
// build the QuotedIdentifierPattern using the quote prefix and suffix from the provider and
// assuming that the quote suffix is escaped via repetition (i.e " becomes "")
stringValue = connection.QuoteChar(ADP.GetSchema);
if (stringValue != null)
{
// by spec a blank identifier quote char indicates that the provider does not suppport
// quoted identifiers
if (stringValue != " ")
{
// only know how to build the pattern if the quote characters is 1 character
// in all other cases just leave the field null
if (stringValue.Length == 1)
{
StringBuilder scratchStringBuilder = new StringBuilder();
ADP.EscapeSpecialCharacters(stringValue, scratchStringBuilder);
string escapedQuoteSuffixString = scratchStringBuilder.ToString();
scratchStringBuilder.Length = 0;
ADP.EscapeSpecialCharacters(stringValue, scratchStringBuilder);
scratchStringBuilder.Append("(([^");
scratchStringBuilder.Append(escapedQuoteSuffixString);
scratchStringBuilder.Append("]|");
scratchStringBuilder.Append(escapedQuoteSuffixString);
scratchStringBuilder.Append(escapedQuoteSuffixString);
scratchStringBuilder.Append(")*)");
scratchStringBuilder.Append(escapedQuoteSuffixString);
dataSourceInformation[DbMetaDataColumnNames.QuotedIdentifierPattern] = scratchStringBuilder.ToString();
}
}
}
// determine the quoted identifier case
retcode = connection.GetInfoInt16Unhandled(ODBC32.SQL_INFO.QUOTED_IDENTIFIER_CASE, out int16Value);
Common.IdentifierCase quotedIdentifierCase = Common.IdentifierCase.Unknown;
if ((retcode == ODBC32.SQLRETURN.SUCCESS) || (retcode == ODBC32.SQLRETURN.SUCCESS_WITH_INFO))
{
switch (int16Value)
{
case (short)ODBC32.SQL_IDENTIFIER_CASE.SENSITIVE:
quotedIdentifierCase = Common.IdentifierCase.Sensitive;
break;
case (short)ODBC32.SQL_IDENTIFIER_CASE.UPPER:
case (short)ODBC32.SQL_IDENTIFIER_CASE.LOWER:
case (short)ODBC32.SQL_IDENTIFIER_CASE.MIXED:
quotedIdentifierCase = Common.IdentifierCase.Insensitive;
break;
}
}
dataSourceInformation[DbMetaDataColumnNames.QuotedIdentifierCase] = quotedIdentifierCase;
dataSourceInformationTable.AcceptChanges();
return dataSourceInformationTable;
}
private DataTable GetDataTypesCollection(string?[]? restrictions, OdbcConnection connection)
{
if (ADP.IsEmptyArray(restrictions) == false)
{
throw ADP.TooManyRestrictions(DbMetaDataCollectionNames.DataTypes);
}
// verify the existance of the table in the data set
DataTable? dataTypesTable = CollectionDataSet.Tables[DbMetaDataCollectionNames.DataTypes];
if (dataTypesTable == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.DataTypes);
}
// copy the data table it
dataTypesTable = CloneAndFilterCollection(DbMetaDataCollectionNames.DataTypes, null);
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
object[] allArguments = new object[1];
allArguments[0] = ODBC32.SQL_ALL_TYPES;
try
{
command = GetCommand(connection);
dataReader = command.ExecuteReaderFromSQLMethod(allArguments, ODBC32.SQL_API.SQLGETTYPEINFO);
DataTableFromDataReaderDataTypes(dataTypesTable, dataReader, connection);
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
dataTypesTable.AcceptChanges();
return dataTypesTable;
}
private DataTable GetIndexCollection(string?[]? restrictions, OdbcConnection connection)
{
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
DataTable? resultTable = null;
const int nativeRestrictionsCount = 5;
const int indexRestrictionsCount = 4;
const int indexOfTableName = 2;
const int indexOfIndexName = 3;
try
{
command = GetCommand(connection);
object[] allRestrictions = new object[nativeRestrictionsCount];
FillOutRestrictions(indexRestrictionsCount, restrictions, allRestrictions, OdbcMetaDataCollectionNames.Indexes);
if (allRestrictions[indexOfTableName] == null)
{
throw ODBC.GetSchemaRestrictionRequired();
}
allRestrictions[3] = (short)ODBC32.SQL_INDEX.ALL;
allRestrictions[4] = (short)ODBC32.SQL_STATISTICS_RESERVED.ENSURE;
dataReader = command.ExecuteReaderFromSQLMethod(allRestrictions, ODBC32.SQL_API.SQLSTATISTICS);
string? indexName = null;
if (restrictions != null)
{
if (restrictions.Length >= indexOfIndexName + 1)
{
indexName = restrictions[indexOfIndexName];
}
}
resultTable = DataTableFromDataReaderIndex(dataReader,
OdbcMetaDataCollectionNames.Indexes,
indexName);
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
return resultTable;
}
private DataTable GetProcedureColumnsCollection(string?[]? restrictions, OdbcConnection connection, bool isColumns)
{
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
DataTable? resultTable = null;
const int procedureColumnsRestrictionsCount = 4;
try
{
command = GetCommand(connection);
string[] allRestrictions = new string[procedureColumnsRestrictionsCount];
FillOutRestrictions(procedureColumnsRestrictionsCount, restrictions, allRestrictions, OdbcMetaDataCollectionNames.Columns);
dataReader = command.ExecuteReaderFromSQLMethod(allRestrictions, ODBC32.SQL_API.SQLPROCEDURECOLUMNS);
string collectionName;
if (isColumns == true)
{
collectionName = OdbcMetaDataCollectionNames.ProcedureColumns;
}
else
{
collectionName = OdbcMetaDataCollectionNames.ProcedureParameters;
}
resultTable = DataTableFromDataReaderProcedureColumns(dataReader,
collectionName,
isColumns);
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
return resultTable;
}
private DataTable GetProceduresCollection(string?[]? restrictions, OdbcConnection connection)
{
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
DataTable? resultTable = null;
const int columnsRestrictionsCount = 4;
const int indexOfProcedureType = 3;
try
{
command = GetCommand(connection);
string?[] allRestrictions = new string[columnsRestrictionsCount];
FillOutRestrictions(columnsRestrictionsCount, restrictions, allRestrictions, OdbcMetaDataCollectionNames.Procedures);
dataReader = command.ExecuteReaderFromSQLMethod(allRestrictions, ODBC32.SQL_API.SQLPROCEDURES);
if (allRestrictions[indexOfProcedureType] == null)
{
resultTable = DataTableFromDataReader(dataReader, OdbcMetaDataCollectionNames.Procedures);
}
else
{
short procedureType;
if ((restrictions![indexOfProcedureType] == "SQL_PT_UNKNOWN") ||
(restrictions[indexOfProcedureType] == "0" /*ODBC32.SQL_PROCEDURETYPE.UNKNOWN*/))
{
procedureType = (short)ODBC32.SQL_PROCEDURETYPE.UNKNOWN;
}
else if ((restrictions[indexOfProcedureType] == "SQL_PT_PROCEDURE") ||
(restrictions[indexOfProcedureType] == "1" /*ODBC32.SQL_PROCEDURETYPE.PROCEDURE*/))
{
procedureType = (short)ODBC32.SQL_PROCEDURETYPE.PROCEDURE;
}
else if ((restrictions[indexOfProcedureType] == "SQL_PT_FUNCTION") ||
(restrictions[indexOfProcedureType] == "2" /*ODBC32.SQL_PROCEDURETYPE.FUNCTION*/))
{
procedureType = (short)ODBC32.SQL_PROCEDURETYPE.FUNCTION;
}
else
{
throw ADP.InvalidRestrictionValue(OdbcMetaDataCollectionNames.Procedures, "PROCEDURE_TYPE", restrictions[indexOfProcedureType]);
}
resultTable = DataTableFromDataReaderProcedures(dataReader, OdbcMetaDataCollectionNames.Procedures, procedureType);
}
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
return resultTable;
}
private DataTable GetReservedWordsCollection(string?[]? restrictions, OdbcConnection connection)
{
if (ADP.IsEmptyArray(restrictions) == false)
{
throw ADP.TooManyRestrictions(DbMetaDataCollectionNames.ReservedWords);
}
// verify the existance of the table in the data set
DataTable? reservedWordsTable = CollectionDataSet.Tables[DbMetaDataCollectionNames.ReservedWords];
if (reservedWordsTable == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.ReservedWords);
}
// copy the table filtering out any rows that don't apply to tho current version of the prrovider
reservedWordsTable = CloneAndFilterCollection(DbMetaDataCollectionNames.ReservedWords, null);
DataColumn? reservedWordColumn = reservedWordsTable.Columns[DbMetaDataColumnNames.ReservedWord];
if (reservedWordColumn == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.ReservedWords);
}
string? keywords = connection.GetInfoStringUnhandled(ODBC32.SQL_INFO.KEYWORDS);
if (null != keywords)
{
string[] values = keywords.Split(KeywordSeparatorChar);
for (int i = 0; i < values.Length; ++i)
{
DataRow row = reservedWordsTable.NewRow();
row[reservedWordColumn] = values[i];
reservedWordsTable.Rows.Add(row);
row.AcceptChanges();
}
}
return reservedWordsTable;
}
private DataTable GetTablesCollection(string?[]? restrictions, OdbcConnection connection, bool isTables)
{
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
DataTable? resultTable = null;
const int tablesRestrictionsCount = 3;
const string includedTableTypesTables = "TABLE,SYSTEM TABLE";
const string includedTableTypesViews = "VIEW";
string includedTableTypes;
string dataTableName;
try
{
//command = (OdbcCommand) connection.CreateCommand();
command = GetCommand(connection);
string[] allArguments = new string[tablesRestrictionsCount + 1];
if (isTables == true)
{
includedTableTypes = includedTableTypesTables;
dataTableName = OdbcMetaDataCollectionNames.Tables;
}
else
{
includedTableTypes = includedTableTypesViews;
dataTableName = OdbcMetaDataCollectionNames.Views;
}
FillOutRestrictions(tablesRestrictionsCount, restrictions, allArguments, dataTableName);
allArguments[tablesRestrictionsCount] = includedTableTypes;
dataReader = command.ExecuteReaderFromSQLMethod(allArguments, ODBC32.SQL_API.SQLTABLES);
resultTable = DataTableFromDataReader(dataReader, dataTableName);
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
return resultTable;
}
private bool IncludeIndexRow(object rowIndexName,
string? restrictionIndexName,
short rowIndexType)
{
// never include table statictics rows
if (rowIndexType == (short)ODBC32.SQL_STATISTICSTYPE.TABLE_STAT)
{
return false;
}
if ((restrictionIndexName != null) && (restrictionIndexName != (string)rowIndexName))
{
return false;
}
return true;
}
private DataTable NewDataTableFromReader(IDataReader reader, out object[] values, string tableName)
{
DataTable resultTable = new DataTable(tableName);
resultTable.Locale = System.Globalization.CultureInfo.InvariantCulture;
DataTable schemaTable = reader.GetSchemaTable()!;
foreach (DataRow row in schemaTable.Rows)
{
resultTable.Columns.Add(row["ColumnName"] as string, (Type)row["DataType"]);
}
values = new object[resultTable.Columns.Count];
return resultTable;
}
protected override DataTable PrepareCollection(string collectionName, string?[]? restrictions, DbConnection connection)
{
DataTable? resultTable = null;
OdbcConnection odbcConnection = (OdbcConnection)connection;
if (collectionName == OdbcMetaDataCollectionNames.Tables)
{
resultTable = GetTablesCollection(restrictions, odbcConnection, true);
}
else if (collectionName == OdbcMetaDataCollectionNames.Views)
{
resultTable = GetTablesCollection(restrictions, odbcConnection, false);
}
else if (collectionName == OdbcMetaDataCollectionNames.Columns)
{
resultTable = GetColumnsCollection(restrictions, odbcConnection);
}
else if (collectionName == OdbcMetaDataCollectionNames.Procedures)
{
resultTable = GetProceduresCollection(restrictions, odbcConnection);
}
else if (collectionName == OdbcMetaDataCollectionNames.ProcedureColumns)
{
resultTable = GetProcedureColumnsCollection(restrictions, odbcConnection, true);
}
else if (collectionName == OdbcMetaDataCollectionNames.ProcedureParameters)
{
resultTable = GetProcedureColumnsCollection(restrictions, odbcConnection, false);
}
else if (collectionName == OdbcMetaDataCollectionNames.Indexes)
{
resultTable = GetIndexCollection(restrictions, odbcConnection);
}
else if (collectionName == DbMetaDataCollectionNames.DataTypes)
{
resultTable = GetDataTypesCollection(restrictions, odbcConnection);
}
else if (collectionName == DbMetaDataCollectionNames.DataSourceInformation)
{
resultTable = GetDataSourceInformationCollection(restrictions, odbcConnection);
}
else if (collectionName == DbMetaDataCollectionNames.ReservedWords)
{
resultTable = GetReservedWordsCollection(restrictions, odbcConnection);
}
if (resultTable == null)
{
throw ADP.UnableToBuildCollection(collectionName);
}
return resultTable;
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.IO;
using System.Data.Common;
using System.Data.ProviderBase;
using System.Diagnostics;
using System.Text;
namespace System.Data.Odbc
{
internal sealed class OdbcMetaDataFactory : DbMetaDataFactory
{
private readonly struct SchemaFunctionName
{
internal SchemaFunctionName(string schemaName, ODBC32.SQL_API odbcFunction)
{
_schemaName = schemaName;
_odbcFunction = odbcFunction;
}
internal readonly string _schemaName;
internal readonly ODBC32.SQL_API _odbcFunction;
}
private const string _collectionName = "CollectionName";
private const string _populationMechanism = "PopulationMechanism";
private const string _prepareCollection = "PrepareCollection";
private readonly SchemaFunctionName[] _schemaMapping;
internal static readonly char[] KeywordSeparatorChar = new char[1] { ',' };
internal OdbcMetaDataFactory(Stream XMLStream,
string serverVersion,
string serverVersionNormalized,
OdbcConnection connection) :
base(XMLStream, serverVersion, serverVersionNormalized)
{
// set up the colletion name ODBC function mapping guid mapping
_schemaMapping = new SchemaFunctionName[] {
new SchemaFunctionName(DbMetaDataCollectionNames.DataTypes, ODBC32.SQL_API.SQLGETTYPEINFO),
new SchemaFunctionName(OdbcMetaDataCollectionNames.Columns, ODBC32.SQL_API.SQLCOLUMNS),
new SchemaFunctionName(OdbcMetaDataCollectionNames.Indexes, ODBC32.SQL_API.SQLSTATISTICS),
new SchemaFunctionName(OdbcMetaDataCollectionNames.Procedures, ODBC32.SQL_API.SQLPROCEDURES),
new SchemaFunctionName(OdbcMetaDataCollectionNames.ProcedureColumns, ODBC32.SQL_API.SQLPROCEDURECOLUMNS),
new SchemaFunctionName(OdbcMetaDataCollectionNames.ProcedureParameters, ODBC32.SQL_API.SQLPROCEDURECOLUMNS),
new SchemaFunctionName(OdbcMetaDataCollectionNames.Tables, ODBC32.SQL_API.SQLTABLES),
new SchemaFunctionName(OdbcMetaDataCollectionNames.Views, ODBC32.SQL_API.SQLTABLES)};
// verify the existance of the table in the data set
DataTable? metaDataCollectionsTable = CollectionDataSet.Tables[DbMetaDataCollectionNames.MetaDataCollections];
if (metaDataCollectionsTable == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.MetaDataCollections);
}
// copy the table filtering out any rows that don't apply to the current version of the provider
metaDataCollectionsTable = CloneAndFilterCollection(DbMetaDataCollectionNames.MetaDataCollections, null);
// verify the existance of the table in the data set
DataTable? restrictionsTable = CollectionDataSet.Tables[DbMetaDataCollectionNames.Restrictions];
if (restrictionsTable != null)
{
// copy the table filtering out any rows that don't apply to the current version of the provider
restrictionsTable = CloneAndFilterCollection(DbMetaDataCollectionNames.Restrictions, null);
}
// need to filter out any of the collections where
// 1) it is populated using prepare collection
// 2) it is in the collection to odbc function mapping above
// 3) the provider does not support the necessary odbc function
DataColumn populationMechanism = metaDataCollectionsTable.Columns[_populationMechanism]!;
DataColumn collectionName = metaDataCollectionsTable.Columns[_collectionName]!;
DataColumn? restrictionCollectionName = null;
if (restrictionsTable != null)
{
restrictionCollectionName = restrictionsTable.Columns[_collectionName];
}
Debug.Assert(restrictionCollectionName != null);
foreach (DataRow collection in metaDataCollectionsTable.Rows)
{
if ((string)collection[populationMechanism] == _prepareCollection)
{
// is the collection in the mapping
int mapping = -1;
for (int i = 0; i < _schemaMapping.Length; i++)
{
if (_schemaMapping[i]._schemaName == (string)collection[collectionName])
{
mapping = i;
break;
}
}
// no go on to the next collection
if (mapping == -1)
{
continue;
}
// does the provider support the necessary odbc function
// if not delete the row from the table
if (connection.SQLGetFunctions(_schemaMapping[mapping]._odbcFunction) == false)
{
// but first delete any related restrictions
if (restrictionsTable != null)
{
foreach (DataRow restriction in restrictionsTable.Rows)
{
if ((string)collection[collectionName] == (string)restriction[restrictionCollectionName])
{
restriction.Delete();
}
}
restrictionsTable.AcceptChanges();
}
collection.Delete();
}
}
}
// replace the original table with the updated one
metaDataCollectionsTable.AcceptChanges();
CollectionDataSet.Tables.Remove(CollectionDataSet.Tables[DbMetaDataCollectionNames.MetaDataCollections]!);
CollectionDataSet.Tables.Add(metaDataCollectionsTable);
if (restrictionsTable != null)
{
CollectionDataSet.Tables.Remove(CollectionDataSet.Tables[DbMetaDataCollectionNames.Restrictions]!);
CollectionDataSet.Tables.Add(restrictionsTable);
}
}
private object BooleanFromODBC(object odbcSource)
{
if (odbcSource != DBNull.Value)
{
//convert to Int32 before doing the comparison
//some odbc drivers report the odbcSource value as unsigned, in which case we will
//have upgraded the type to Int32, and thus can't cast directly to short
if (Convert.ToInt32(odbcSource, null) == 0)
{
return false;
}
else
{
return true;
}
}
return DBNull.Value;
}
private OdbcCommand GetCommand(OdbcConnection connection)
{
OdbcCommand command = connection.CreateCommand();
// You need to make sure you pick up the transaction from the connection,
// or odd things can happen...
command.Transaction = connection.LocalTransaction;
return command;
}
private DataTable DataTableFromDataReader(IDataReader reader, string tableName)
{
// set up the column structure of the data table from the reader
object[] values;
DataTable resultTable = NewDataTableFromReader(reader, out values, tableName);
// populate the data table from the data reader
while (reader.Read())
{
reader.GetValues(values);
resultTable.Rows.Add(values);
}
return resultTable;
}
private void DataTableFromDataReaderDataTypes(DataTable dataTypesTable, OdbcDataReader dataReader, OdbcConnection connection)
{
DataTable? schemaTable;
//
// Build a DataTable from the reader
schemaTable = dataReader.GetSchemaTable();
// vstfdevdiv:479715 Handle cases where reader is empty
if (null == schemaTable)
{
throw ADP.OdbcNoTypesFromProvider();
}
object[] getTypeInfoValues = new object[schemaTable.Rows.Count];
DataRow dataTypesRow;
DataColumn typeNameColumn = dataTypesTable.Columns[DbMetaDataColumnNames.TypeName]!;
DataColumn providerDbTypeColumn = dataTypesTable.Columns[DbMetaDataColumnNames.ProviderDbType]!;
DataColumn columnSizeColumn = dataTypesTable.Columns[DbMetaDataColumnNames.ColumnSize]!;
DataColumn createParametersColumn = dataTypesTable.Columns[DbMetaDataColumnNames.CreateParameters]!;
DataColumn dataTypeColumn = dataTypesTable.Columns[DbMetaDataColumnNames.DataType]!;
DataColumn isAutoIncermentableColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsAutoIncrementable]!;
DataColumn isCaseSensitiveColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsCaseSensitive]!;
DataColumn isFixedLengthColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsFixedLength]!;
DataColumn isFixedPrecisionScaleColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsFixedPrecisionScale]!;
DataColumn isLongColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsLong]!;
DataColumn isNullableColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsNullable]!;
DataColumn isSearchableColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsSearchable]!;
DataColumn isSearchableWithLikeColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsSearchableWithLike]!;
DataColumn isUnsignedColumn = dataTypesTable.Columns[DbMetaDataColumnNames.IsUnsigned]!;
DataColumn maximumScaleColumn = dataTypesTable.Columns[DbMetaDataColumnNames.MaximumScale]!;
DataColumn minimumScaleColumn = dataTypesTable.Columns[DbMetaDataColumnNames.MinimumScale]!;
DataColumn literalPrefixColumn = dataTypesTable.Columns[DbMetaDataColumnNames.LiteralPrefix]!;
DataColumn literalSuffixColumn = dataTypesTable.Columns[DbMetaDataColumnNames.LiteralSuffix]!;
DataColumn SQLTypeNameColumn = dataTypesTable.Columns[OdbcMetaDataColumnNames.SQLType]!;
const int indexTYPE_NAME = 0;
const int indexDATA_TYPE = 1;
const int indexCOLUMN_SIZE = 2;
const int indexCREATE_PARAMS = 5;
const int indexAUTO_UNIQUE_VALUE = 11;
const int indexCASE_SENSITIVE = 7;
const int indexFIXED_PREC_SCALE = 10;
const int indexNULLABLE = 6;
const int indexSEARCHABLE = 8;
const int indexUNSIGNED_ATTRIBUTE = 9;
const int indexMAXIMUM_SCALE = 14;
const int indexMINIMUM_SCALE = 13;
const int indexLITERAL_PREFIX = 3;
const int indexLITERAL_SUFFIX = 4;
const int SQL_DATE_V2 = 9;
const int SQL_TIME_V2 = 10;
TypeMap? typeMap;
while (dataReader.Read())
{
dataReader.GetValues(getTypeInfoValues);
dataTypesRow = dataTypesTable.NewRow();
ODBC32.SQL_TYPE sqlType;
dataTypesRow[typeNameColumn] = getTypeInfoValues[indexTYPE_NAME];
dataTypesRow[SQLTypeNameColumn] = getTypeInfoValues[indexDATA_TYPE];
sqlType = (ODBC32.SQL_TYPE)(int)Convert.ChangeType(getTypeInfoValues[indexDATA_TYPE], typeof(int), null);
// if the driver is pre version 3 and it returned the v2 SQL_DATE or SQL_TIME types they need
// to be mapped to their v3 equivalent
if (connection.IsV3Driver == false)
{
if ((int)sqlType == SQL_DATE_V2)
{
sqlType = ODBC32.SQL_TYPE.TYPE_DATE;
}
else if ((int)sqlType == SQL_TIME_V2)
{
sqlType = ODBC32.SQL_TYPE.TYPE_TIME;
}
}
try
{
typeMap = TypeMap.FromSqlType(sqlType);
}
// FromSqlType will throw an argument exception if it does not recognize the SqlType.
// This is not an error since the GetTypeInfo DATA_TYPE may be a SQL data type or a driver specific
// type. If there is no TypeMap for the type its not an error but it will degrade our level of
// understanding of/ support for the type.
catch (ArgumentException)
{
typeMap = null;
}
// if we have a type map we can determine the dbType and the CLR type if not leave them null
if (typeMap != null)
{
dataTypesRow[providerDbTypeColumn] = typeMap._odbcType;
dataTypesRow[dataTypeColumn] = typeMap._type.FullName;
// setting isLong and isFixedLength only if we have a type map because for provider
// specific types we have no idea what the types attributes are if GetTypeInfo did not
// tell us
switch (sqlType)
{
case ODBC32.SQL_TYPE.LONGVARCHAR:
case ODBC32.SQL_TYPE.WLONGVARCHAR:
case ODBC32.SQL_TYPE.LONGVARBINARY:
case ODBC32.SQL_TYPE.SS_XML:
dataTypesRow[isLongColumn] = true;
dataTypesRow[isFixedLengthColumn] = false;
break;
case ODBC32.SQL_TYPE.VARCHAR:
case ODBC32.SQL_TYPE.WVARCHAR:
case ODBC32.SQL_TYPE.VARBINARY:
dataTypesRow[isLongColumn] = false;
dataTypesRow[isFixedLengthColumn] = false;
break;
case ODBC32.SQL_TYPE.CHAR:
case ODBC32.SQL_TYPE.WCHAR:
case ODBC32.SQL_TYPE.DECIMAL:
case ODBC32.SQL_TYPE.NUMERIC:
case ODBC32.SQL_TYPE.SMALLINT:
case ODBC32.SQL_TYPE.INTEGER:
case ODBC32.SQL_TYPE.REAL:
case ODBC32.SQL_TYPE.FLOAT:
case ODBC32.SQL_TYPE.DOUBLE:
case ODBC32.SQL_TYPE.BIT:
case ODBC32.SQL_TYPE.TINYINT:
case ODBC32.SQL_TYPE.BIGINT:
case ODBC32.SQL_TYPE.TYPE_DATE:
case ODBC32.SQL_TYPE.TYPE_TIME:
case ODBC32.SQL_TYPE.TIMESTAMP:
case ODBC32.SQL_TYPE.TYPE_TIMESTAMP:
case ODBC32.SQL_TYPE.GUID:
case ODBC32.SQL_TYPE.SS_VARIANT:
case ODBC32.SQL_TYPE.SS_UTCDATETIME:
case ODBC32.SQL_TYPE.SS_TIME_EX:
case ODBC32.SQL_TYPE.BINARY:
dataTypesRow[isLongColumn] = false;
dataTypesRow[isFixedLengthColumn] = true;
break;
case ODBC32.SQL_TYPE.SS_UDT:
default:
// for User defined types don't know if its long or if it is
// varaible length or not so leave the fields null
break;
}
}
dataTypesRow[columnSizeColumn] = getTypeInfoValues[indexCOLUMN_SIZE];
dataTypesRow[createParametersColumn] = getTypeInfoValues[indexCREATE_PARAMS];
if ((getTypeInfoValues[indexAUTO_UNIQUE_VALUE] == DBNull.Value) ||
(Convert.ToInt16(getTypeInfoValues[indexAUTO_UNIQUE_VALUE], null) == 0))
{
dataTypesRow[isAutoIncermentableColumn] = false;
}
else
{
dataTypesRow[isAutoIncermentableColumn] = true;
}
dataTypesRow[isCaseSensitiveColumn] = BooleanFromODBC(getTypeInfoValues[indexCASE_SENSITIVE]);
dataTypesRow[isFixedPrecisionScaleColumn] = BooleanFromODBC(getTypeInfoValues[indexFIXED_PREC_SCALE]);
if (getTypeInfoValues[indexNULLABLE] != DBNull.Value)
{
//Use Convert.ToInt16 instead of direct cast to short because the value will be Int32 in some cases
switch ((ODBC32.SQL_NULLABILITY)Convert.ToInt16(getTypeInfoValues[indexNULLABLE], null))
{
case ODBC32.SQL_NULLABILITY.NO_NULLS:
dataTypesRow[isNullableColumn] = false;
break;
case ODBC32.SQL_NULLABILITY.NULLABLE:
dataTypesRow[isNullableColumn] = true;
break;
case ODBC32.SQL_NULLABILITY.UNKNOWN:
dataTypesRow[isNullableColumn] = DBNull.Value;
break;
}
}
if (DBNull.Value != getTypeInfoValues[indexSEARCHABLE])
{
//Use Convert.ToInt16 instead of direct cast to short because the value will be Int32 in some cases
short searchableValue = Convert.ToInt16(getTypeInfoValues[indexSEARCHABLE], null);
switch (searchableValue)
{
case (short)ODBC32.SQL_SEARCHABLE.UNSEARCHABLE:
dataTypesRow[isSearchableColumn] = false;
dataTypesRow[isSearchableWithLikeColumn] = false;
break;
case (short)ODBC32.SQL_SEARCHABLE.LIKE_ONLY:
dataTypesRow[isSearchableColumn] = false;
dataTypesRow[isSearchableWithLikeColumn] = true;
break;
case (short)ODBC32.SQL_SEARCHABLE.ALL_EXCEPT_LIKE:
dataTypesRow[isSearchableColumn] = true;
dataTypesRow[isSearchableWithLikeColumn] = false;
break;
case (short)ODBC32.SQL_SEARCHABLE.SEARCHABLE:
dataTypesRow[isSearchableColumn] = true;
dataTypesRow[isSearchableWithLikeColumn] = true;
break;
}
}
dataTypesRow[isUnsignedColumn] = BooleanFromODBC(getTypeInfoValues[indexUNSIGNED_ATTRIBUTE]);
//For assignment to the DataSet, don't cast the data types -- let the DataSet take care of any conversion
if (getTypeInfoValues[indexMAXIMUM_SCALE] != DBNull.Value)
{
dataTypesRow[maximumScaleColumn] = getTypeInfoValues[indexMAXIMUM_SCALE];
}
if (getTypeInfoValues[indexMINIMUM_SCALE] != DBNull.Value)
{
dataTypesRow[minimumScaleColumn] = getTypeInfoValues[indexMINIMUM_SCALE];
}
if (getTypeInfoValues[indexLITERAL_PREFIX] != DBNull.Value)
{
dataTypesRow[literalPrefixColumn] = getTypeInfoValues[indexLITERAL_PREFIX];
}
if (getTypeInfoValues[indexLITERAL_SUFFIX] != DBNull.Value)
{
dataTypesRow[literalSuffixColumn] = getTypeInfoValues[indexLITERAL_SUFFIX];
}
dataTypesTable.Rows.Add(dataTypesRow);
}
}
private DataTable DataTableFromDataReaderIndex(IDataReader reader,
string tableName,
string? restrictionIndexName)
{
// set up the column structure of the data table from the reader
object[] values;
DataTable resultTable = NewDataTableFromReader(reader, out values, tableName);
// populate the data table from the data reader
int positionOfType = 6;
int positionOfIndexName = 5;
while (reader.Read())
{
reader.GetValues(values);
if (IncludeIndexRow(values[positionOfIndexName],
restrictionIndexName,
Convert.ToInt16(values[positionOfType], null)) == true)
{
resultTable.Rows.Add(values);
}
}
return resultTable;
}
private DataTable DataTableFromDataReaderProcedureColumns(IDataReader reader, string tableName, bool isColumn)
{
// set up the column structure of the data table from the reader
object[] values;
DataTable resultTable = NewDataTableFromReader(reader, out values, tableName);
// populate the data table from the data reader
int positionOfColumnType = 4;
while (reader.Read())
{
reader.GetValues(values);
// the column type should always be short but need to check just in case
if (values[positionOfColumnType].GetType() == typeof(short))
{
if ((((short)values[positionOfColumnType] == ODBC32.SQL_RESULT_COL) && (isColumn == true)) ||
(((short)values[positionOfColumnType] != ODBC32.SQL_RESULT_COL) && (isColumn == false)))
{
resultTable.Rows.Add(values);
}
}
}
return resultTable;
}
private DataTable DataTableFromDataReaderProcedures(IDataReader reader, string tableName, short procedureType)
{
// Build a DataTable from the reader
// set up the column structure of the data table from the reader
object[] values;
DataTable resultTable = NewDataTableFromReader(reader, out values, tableName);
// populate the data table from the data reader
int positionOfProcedureType = 7;
while (reader.Read())
{
reader.GetValues(values);
// the column type should always be short but need to check just in case its null
if (values[positionOfProcedureType].GetType() == typeof(short))
{
if ((short)values[positionOfProcedureType] == procedureType)
{
resultTable.Rows.Add(values);
}
}
}
return resultTable;
}
private void FillOutRestrictions(int restrictionsCount, string?[]? restrictions, object?[] allRestrictions, string collectionName)
{
Debug.Assert(allRestrictions.Length >= restrictionsCount);
int i = 0;
// if we have restrictions put them in the restrictions array
if (restrictions != null)
{
if (restrictions.Length > restrictionsCount)
{
throw ADP.TooManyRestrictions(collectionName);
}
for (i = 0; i < restrictions.Length; i++)
{
if (restrictions[i] != null)
{
allRestrictions[i] = restrictions[i];
}
}
}
// initalize the rest to no restrictions
for (; i < restrictionsCount; i++)
{
allRestrictions[i] = null;
}
}
private DataTable GetColumnsCollection(string?[]? restrictions, OdbcConnection connection)
{
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
DataTable? resultTable = null;
const int columnsRestrictionsCount = 4;
try
{
command = GetCommand(connection);
string[] allRestrictions = new string[columnsRestrictionsCount];
FillOutRestrictions(columnsRestrictionsCount, restrictions, allRestrictions, OdbcMetaDataCollectionNames.Columns);
dataReader = command.ExecuteReaderFromSQLMethod(allRestrictions, ODBC32.SQL_API.SQLCOLUMNS);
resultTable = DataTableFromDataReader(dataReader, OdbcMetaDataCollectionNames.Columns);
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
return resultTable;
}
private DataTable GetDataSourceInformationCollection(string?[]? restrictions,
OdbcConnection connection)
{
if (ADP.IsEmptyArray(restrictions) == false)
{
throw ADP.TooManyRestrictions(DbMetaDataCollectionNames.DataSourceInformation);
}
// verify that the data source information table is in the data set
DataTable? dataSourceInformationTable = CollectionDataSet.Tables[DbMetaDataCollectionNames.DataSourceInformation];
if (dataSourceInformationTable == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.DataSourceInformation);
}
// copy the table filtering out any rows that don't apply to the current version of the provider
dataSourceInformationTable = CloneAndFilterCollection(DbMetaDataCollectionNames.DataSourceInformation, null);
// after filtering there better be just one row
if (dataSourceInformationTable.Rows.Count != 1)
{
throw ADP.IncorrectNumberOfDataSourceInformationRows();
}
DataRow dataSourceInformation = dataSourceInformationTable.Rows[0];
string? stringValue;
short int16Value;
int int32Value;
ODBC32.SQLRETURN retcode;
// update the catalog separator
stringValue = connection.GetInfoStringUnhandled(ODBC32.SQL_INFO.CATALOG_NAME_SEPARATOR);
if (!string.IsNullOrEmpty(stringValue))
{
StringBuilder patternEscaped = new StringBuilder();
ADP.EscapeSpecialCharacters(stringValue, patternEscaped);
dataSourceInformation[DbMetaDataColumnNames.CompositeIdentifierSeparatorPattern] = patternEscaped.ToString();
}
// get the DBMS Name
stringValue = connection.GetInfoStringUnhandled(ODBC32.SQL_INFO.DBMS_NAME);
if (stringValue != null)
{
dataSourceInformation[DbMetaDataColumnNames.DataSourceProductName] = stringValue;
}
// update the server version strings
dataSourceInformation[DbMetaDataColumnNames.DataSourceProductVersion] = ServerVersion;
dataSourceInformation[DbMetaDataColumnNames.DataSourceProductVersionNormalized] = ServerVersionNormalized;
// values that are the same for all ODBC drivers. See bug 105333
dataSourceInformation[DbMetaDataColumnNames.ParameterMarkerFormat] = "?";
dataSourceInformation[DbMetaDataColumnNames.ParameterMarkerPattern] = "\\?";
dataSourceInformation[DbMetaDataColumnNames.ParameterNameMaxLength] = 0;
// determine the supportedJoinOperators
// leave the column null if the GetInfo fails. There is no explicit value for
// unknown.
if (connection.IsV3Driver)
{
retcode = connection.GetInfoInt32Unhandled(ODBC32.SQL_INFO.SQL_OJ_CAPABILITIES_30, out int32Value);
}
else
{
retcode = connection.GetInfoInt32Unhandled(ODBC32.SQL_INFO.SQL_OJ_CAPABILITIES_20, out int32Value);
}
if ((retcode == ODBC32.SQLRETURN.SUCCESS) || (retcode == ODBC32.SQLRETURN.SUCCESS_WITH_INFO))
{
Common.SupportedJoinOperators supportedJoinOperators = Common.SupportedJoinOperators.None;
if ((int32Value & (int)ODBC32.SQL_OJ_CAPABILITIES.LEFT) != 0)
{
supportedJoinOperators = supportedJoinOperators | Common.SupportedJoinOperators.LeftOuter;
}
if ((int32Value & (int)ODBC32.SQL_OJ_CAPABILITIES.RIGHT) != 0)
{
supportedJoinOperators = supportedJoinOperators | Common.SupportedJoinOperators.RightOuter;
}
if ((int32Value & (int)ODBC32.SQL_OJ_CAPABILITIES.FULL) != 0)
{
supportedJoinOperators = supportedJoinOperators | Common.SupportedJoinOperators.FullOuter;
}
if ((int32Value & (int)ODBC32.SQL_OJ_CAPABILITIES.INNER) != 0)
{
supportedJoinOperators = supportedJoinOperators | Common.SupportedJoinOperators.Inner;
}
dataSourceInformation[DbMetaDataColumnNames.SupportedJoinOperators] = supportedJoinOperators;
}
// determine the GroupByBehavior
retcode = connection.GetInfoInt16Unhandled(ODBC32.SQL_INFO.GROUP_BY, out int16Value);
Common.GroupByBehavior groupByBehavior = Common.GroupByBehavior.Unknown;
if ((retcode == ODBC32.SQLRETURN.SUCCESS) || (retcode == ODBC32.SQLRETURN.SUCCESS_WITH_INFO))
{
switch (int16Value)
{
case (short)ODBC32.SQL_GROUP_BY.NOT_SUPPORTED:
groupByBehavior = Common.GroupByBehavior.NotSupported;
break;
case (short)ODBC32.SQL_GROUP_BY.GROUP_BY_EQUALS_SELECT:
groupByBehavior = Common.GroupByBehavior.ExactMatch;
break;
case (short)ODBC32.SQL_GROUP_BY.GROUP_BY_CONTAINS_SELECT:
groupByBehavior = Common.GroupByBehavior.MustContainAll;
break;
case (short)ODBC32.SQL_GROUP_BY.NO_RELATION:
groupByBehavior = Common.GroupByBehavior.Unrelated;
break;
/* COLLATE is new in ODBC 3.0 and GroupByBehavior does not have a value for it.
case ODBC32.SQL_GROUP_BY.COLLATE:
groupByBehavior = Common.GroupByBehavior.Unknown;
break;
*/
}
}
dataSourceInformation[DbMetaDataColumnNames.GroupByBehavior] = groupByBehavior;
// determine the identifier case
retcode = connection.GetInfoInt16Unhandled(ODBC32.SQL_INFO.IDENTIFIER_CASE, out int16Value);
Common.IdentifierCase identifierCase = Common.IdentifierCase.Unknown;
if ((retcode == ODBC32.SQLRETURN.SUCCESS) || (retcode == ODBC32.SQLRETURN.SUCCESS_WITH_INFO))
{
switch (int16Value)
{
case (short)ODBC32.SQL_IDENTIFIER_CASE.SENSITIVE:
identifierCase = Common.IdentifierCase.Sensitive;
break;
case (short)ODBC32.SQL_IDENTIFIER_CASE.UPPER:
case (short)ODBC32.SQL_IDENTIFIER_CASE.LOWER:
case (short)ODBC32.SQL_IDENTIFIER_CASE.MIXED:
identifierCase = Common.IdentifierCase.Insensitive;
break;
}
}
dataSourceInformation[DbMetaDataColumnNames.IdentifierCase] = identifierCase;
// OrderByColumnsInSelect
stringValue = connection.GetInfoStringUnhandled(ODBC32.SQL_INFO.ORDER_BY_COLUMNS_IN_SELECT);
if (stringValue != null)
{
if (stringValue == "Y")
{
dataSourceInformation[DbMetaDataColumnNames.OrderByColumnsInSelect] = true;
}
else if (stringValue == "N")
{
dataSourceInformation[DbMetaDataColumnNames.OrderByColumnsInSelect] = false;
}
}
// build the QuotedIdentifierPattern using the quote prefix and suffix from the provider and
// assuming that the quote suffix is escaped via repetition (i.e " becomes "")
stringValue = connection.QuoteChar(ADP.GetSchema);
if (stringValue != null)
{
// by spec a blank identifier quote char indicates that the provider does not suppport
// quoted identifiers
if (stringValue != " ")
{
// only know how to build the pattern if the quote characters is 1 character
// in all other cases just leave the field null
if (stringValue.Length == 1)
{
StringBuilder scratchStringBuilder = new StringBuilder();
ADP.EscapeSpecialCharacters(stringValue, scratchStringBuilder);
string escapedQuoteSuffixString = scratchStringBuilder.ToString();
scratchStringBuilder.Length = 0;
ADP.EscapeSpecialCharacters(stringValue, scratchStringBuilder);
scratchStringBuilder.Append("(([^");
scratchStringBuilder.Append(escapedQuoteSuffixString);
scratchStringBuilder.Append("]|");
scratchStringBuilder.Append(escapedQuoteSuffixString);
scratchStringBuilder.Append(escapedQuoteSuffixString);
scratchStringBuilder.Append(")*)");
scratchStringBuilder.Append(escapedQuoteSuffixString);
dataSourceInformation[DbMetaDataColumnNames.QuotedIdentifierPattern] = scratchStringBuilder.ToString();
}
}
}
// determine the quoted identifier case
retcode = connection.GetInfoInt16Unhandled(ODBC32.SQL_INFO.QUOTED_IDENTIFIER_CASE, out int16Value);
Common.IdentifierCase quotedIdentifierCase = Common.IdentifierCase.Unknown;
if ((retcode == ODBC32.SQLRETURN.SUCCESS) || (retcode == ODBC32.SQLRETURN.SUCCESS_WITH_INFO))
{
switch (int16Value)
{
case (short)ODBC32.SQL_IDENTIFIER_CASE.SENSITIVE:
quotedIdentifierCase = Common.IdentifierCase.Sensitive;
break;
case (short)ODBC32.SQL_IDENTIFIER_CASE.UPPER:
case (short)ODBC32.SQL_IDENTIFIER_CASE.LOWER:
case (short)ODBC32.SQL_IDENTIFIER_CASE.MIXED:
quotedIdentifierCase = Common.IdentifierCase.Insensitive;
break;
}
}
dataSourceInformation[DbMetaDataColumnNames.QuotedIdentifierCase] = quotedIdentifierCase;
dataSourceInformationTable.AcceptChanges();
return dataSourceInformationTable;
}
private DataTable GetDataTypesCollection(string?[]? restrictions, OdbcConnection connection)
{
if (ADP.IsEmptyArray(restrictions) == false)
{
throw ADP.TooManyRestrictions(DbMetaDataCollectionNames.DataTypes);
}
// verify the existance of the table in the data set
DataTable? dataTypesTable = CollectionDataSet.Tables[DbMetaDataCollectionNames.DataTypes];
if (dataTypesTable == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.DataTypes);
}
// copy the data table it
dataTypesTable = CloneAndFilterCollection(DbMetaDataCollectionNames.DataTypes, null);
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
object[] allArguments = new object[1];
allArguments[0] = ODBC32.SQL_ALL_TYPES;
try
{
command = GetCommand(connection);
dataReader = command.ExecuteReaderFromSQLMethod(allArguments, ODBC32.SQL_API.SQLGETTYPEINFO);
DataTableFromDataReaderDataTypes(dataTypesTable, dataReader, connection);
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
dataTypesTable.AcceptChanges();
return dataTypesTable;
}
private DataTable GetIndexCollection(string?[]? restrictions, OdbcConnection connection)
{
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
DataTable? resultTable = null;
const int nativeRestrictionsCount = 5;
const int indexRestrictionsCount = 4;
const int indexOfTableName = 2;
const int indexOfIndexName = 3;
try
{
command = GetCommand(connection);
object[] allRestrictions = new object[nativeRestrictionsCount];
FillOutRestrictions(indexRestrictionsCount, restrictions, allRestrictions, OdbcMetaDataCollectionNames.Indexes);
if (allRestrictions[indexOfTableName] == null)
{
throw ODBC.GetSchemaRestrictionRequired();
}
allRestrictions[3] = (short)ODBC32.SQL_INDEX.ALL;
allRestrictions[4] = (short)ODBC32.SQL_STATISTICS_RESERVED.ENSURE;
dataReader = command.ExecuteReaderFromSQLMethod(allRestrictions, ODBC32.SQL_API.SQLSTATISTICS);
string? indexName = null;
if (restrictions != null)
{
if (restrictions.Length >= indexOfIndexName + 1)
{
indexName = restrictions[indexOfIndexName];
}
}
resultTable = DataTableFromDataReaderIndex(dataReader,
OdbcMetaDataCollectionNames.Indexes,
indexName);
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
return resultTable;
}
private DataTable GetProcedureColumnsCollection(string?[]? restrictions, OdbcConnection connection, bool isColumns)
{
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
DataTable? resultTable = null;
const int procedureColumnsRestrictionsCount = 4;
try
{
command = GetCommand(connection);
string[] allRestrictions = new string[procedureColumnsRestrictionsCount];
FillOutRestrictions(procedureColumnsRestrictionsCount, restrictions, allRestrictions, OdbcMetaDataCollectionNames.Columns);
dataReader = command.ExecuteReaderFromSQLMethod(allRestrictions, ODBC32.SQL_API.SQLPROCEDURECOLUMNS);
string collectionName;
if (isColumns == true)
{
collectionName = OdbcMetaDataCollectionNames.ProcedureColumns;
}
else
{
collectionName = OdbcMetaDataCollectionNames.ProcedureParameters;
}
resultTable = DataTableFromDataReaderProcedureColumns(dataReader,
collectionName,
isColumns);
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
return resultTable;
}
private DataTable GetProceduresCollection(string?[]? restrictions, OdbcConnection connection)
{
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
DataTable? resultTable = null;
const int columnsRestrictionsCount = 4;
const int indexOfProcedureType = 3;
try
{
command = GetCommand(connection);
string?[] allRestrictions = new string[columnsRestrictionsCount];
FillOutRestrictions(columnsRestrictionsCount, restrictions, allRestrictions, OdbcMetaDataCollectionNames.Procedures);
dataReader = command.ExecuteReaderFromSQLMethod(allRestrictions, ODBC32.SQL_API.SQLPROCEDURES);
if (allRestrictions[indexOfProcedureType] == null)
{
resultTable = DataTableFromDataReader(dataReader, OdbcMetaDataCollectionNames.Procedures);
}
else
{
short procedureType;
if ((restrictions![indexOfProcedureType] == "SQL_PT_UNKNOWN") ||
(restrictions[indexOfProcedureType] == "0" /*ODBC32.SQL_PROCEDURETYPE.UNKNOWN*/))
{
procedureType = (short)ODBC32.SQL_PROCEDURETYPE.UNKNOWN;
}
else if ((restrictions[indexOfProcedureType] == "SQL_PT_PROCEDURE") ||
(restrictions[indexOfProcedureType] == "1" /*ODBC32.SQL_PROCEDURETYPE.PROCEDURE*/))
{
procedureType = (short)ODBC32.SQL_PROCEDURETYPE.PROCEDURE;
}
else if ((restrictions[indexOfProcedureType] == "SQL_PT_FUNCTION") ||
(restrictions[indexOfProcedureType] == "2" /*ODBC32.SQL_PROCEDURETYPE.FUNCTION*/))
{
procedureType = (short)ODBC32.SQL_PROCEDURETYPE.FUNCTION;
}
else
{
throw ADP.InvalidRestrictionValue(OdbcMetaDataCollectionNames.Procedures, "PROCEDURE_TYPE", restrictions[indexOfProcedureType]);
}
resultTable = DataTableFromDataReaderProcedures(dataReader, OdbcMetaDataCollectionNames.Procedures, procedureType);
}
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
return resultTable;
}
private DataTable GetReservedWordsCollection(string?[]? restrictions, OdbcConnection connection)
{
if (ADP.IsEmptyArray(restrictions) == false)
{
throw ADP.TooManyRestrictions(DbMetaDataCollectionNames.ReservedWords);
}
// verify the existance of the table in the data set
DataTable? reservedWordsTable = CollectionDataSet.Tables[DbMetaDataCollectionNames.ReservedWords];
if (reservedWordsTable == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.ReservedWords);
}
// copy the table filtering out any rows that don't apply to tho current version of the prrovider
reservedWordsTable = CloneAndFilterCollection(DbMetaDataCollectionNames.ReservedWords, null);
DataColumn? reservedWordColumn = reservedWordsTable.Columns[DbMetaDataColumnNames.ReservedWord];
if (reservedWordColumn == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.ReservedWords);
}
string? keywords = connection.GetInfoStringUnhandled(ODBC32.SQL_INFO.KEYWORDS);
if (null != keywords)
{
string[] values = keywords.Split(KeywordSeparatorChar);
for (int i = 0; i < values.Length; ++i)
{
DataRow row = reservedWordsTable.NewRow();
row[reservedWordColumn] = values[i];
reservedWordsTable.Rows.Add(row);
row.AcceptChanges();
}
}
return reservedWordsTable;
}
private DataTable GetTablesCollection(string?[]? restrictions, OdbcConnection connection, bool isTables)
{
OdbcCommand? command = null;
OdbcDataReader? dataReader = null;
DataTable? resultTable = null;
const int tablesRestrictionsCount = 3;
const string includedTableTypesTables = "TABLE,SYSTEM TABLE";
const string includedTableTypesViews = "VIEW";
string includedTableTypes;
string dataTableName;
try
{
//command = (OdbcCommand) connection.CreateCommand();
command = GetCommand(connection);
string[] allArguments = new string[tablesRestrictionsCount + 1];
if (isTables == true)
{
includedTableTypes = includedTableTypesTables;
dataTableName = OdbcMetaDataCollectionNames.Tables;
}
else
{
includedTableTypes = includedTableTypesViews;
dataTableName = OdbcMetaDataCollectionNames.Views;
}
FillOutRestrictions(tablesRestrictionsCount, restrictions, allArguments, dataTableName);
allArguments[tablesRestrictionsCount] = includedTableTypes;
dataReader = command.ExecuteReaderFromSQLMethod(allArguments, ODBC32.SQL_API.SQLTABLES);
resultTable = DataTableFromDataReader(dataReader, dataTableName);
}
finally
{
if (dataReader != null)
{
dataReader.Dispose();
};
if (command != null)
{
command.Dispose();
};
}
return resultTable;
}
private bool IncludeIndexRow(object rowIndexName,
string? restrictionIndexName,
short rowIndexType)
{
// never include table statictics rows
if (rowIndexType == (short)ODBC32.SQL_STATISTICSTYPE.TABLE_STAT)
{
return false;
}
if ((restrictionIndexName != null) && (restrictionIndexName != (string)rowIndexName))
{
return false;
}
return true;
}
private DataTable NewDataTableFromReader(IDataReader reader, out object[] values, string tableName)
{
DataTable resultTable = new DataTable(tableName);
resultTable.Locale = System.Globalization.CultureInfo.InvariantCulture;
DataTable schemaTable = reader.GetSchemaTable()!;
foreach (DataRow row in schemaTable.Rows)
{
resultTable.Columns.Add(row["ColumnName"] as string, (Type)row["DataType"]);
}
values = new object[resultTable.Columns.Count];
return resultTable;
}
protected override DataTable PrepareCollection(string collectionName, string?[]? restrictions, DbConnection connection)
{
DataTable? resultTable = null;
OdbcConnection odbcConnection = (OdbcConnection)connection;
if (collectionName == OdbcMetaDataCollectionNames.Tables)
{
resultTable = GetTablesCollection(restrictions, odbcConnection, true);
}
else if (collectionName == OdbcMetaDataCollectionNames.Views)
{
resultTable = GetTablesCollection(restrictions, odbcConnection, false);
}
else if (collectionName == OdbcMetaDataCollectionNames.Columns)
{
resultTable = GetColumnsCollection(restrictions, odbcConnection);
}
else if (collectionName == OdbcMetaDataCollectionNames.Procedures)
{
resultTable = GetProceduresCollection(restrictions, odbcConnection);
}
else if (collectionName == OdbcMetaDataCollectionNames.ProcedureColumns)
{
resultTable = GetProcedureColumnsCollection(restrictions, odbcConnection, true);
}
else if (collectionName == OdbcMetaDataCollectionNames.ProcedureParameters)
{
resultTable = GetProcedureColumnsCollection(restrictions, odbcConnection, false);
}
else if (collectionName == OdbcMetaDataCollectionNames.Indexes)
{
resultTable = GetIndexCollection(restrictions, odbcConnection);
}
else if (collectionName == DbMetaDataCollectionNames.DataTypes)
{
resultTable = GetDataTypesCollection(restrictions, odbcConnection);
}
else if (collectionName == DbMetaDataCollectionNames.DataSourceInformation)
{
resultTable = GetDataSourceInformationCollection(restrictions, odbcConnection);
}
else if (collectionName == DbMetaDataCollectionNames.ReservedWords)
{
resultTable = GetReservedWordsCollection(restrictions, odbcConnection);
}
if (resultTable == null)
{
throw ADP.UnableToBuildCollection(collectionName);
}
return resultTable;
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Net.Http/tests/StressTests/HttpStress/Program.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Microsoft.AspNetCore;
using System;
using System.Collections.Generic;
using System.CommandLine;
using System.IO;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using System.Net;
using HttpStress;
[assembly:SupportedOSPlatform("windows")]
[assembly:SupportedOSPlatform("linux")]
namespace HttpStress
{
/// <summary>
/// Simple HttpClient stress app that launches Kestrel in-proc and runs many concurrent requests of varying types against it.
/// </summary>
public static class Program
{
public enum ExitCode { Success = 0, StressError = 1, CliError = 2 };
public static async Task<int> Main(string[] args)
{
if (!TryParseCli(args, out Configuration? config))
{
return (int)ExitCode.CliError;
}
return (int)await Run(config);
}
private static bool TryParseCli(string[] args, [NotNullWhen(true)] out Configuration? config)
{
var cmd = new RootCommand();
cmd.AddOption(new Option("-n", "Max number of requests to make concurrently.") { Argument = new Argument<int>("numWorkers", Environment.ProcessorCount) });
cmd.AddOption(new Option("-serverUri", "Stress suite server uri.") { Argument = new Argument<string>("serverUri", "https://localhost:5001") });
cmd.AddOption(new Option("-runMode", "Stress suite execution mode. Defaults to Both.") { Argument = new Argument<RunMode>("runMode", RunMode.both) });
cmd.AddOption(new Option("-maxExecutionTime", "Maximum stress execution time, in minutes. Defaults to infinity.") { Argument = new Argument<double?>("minutes", null) });
cmd.AddOption(new Option("-maxContentLength", "Max content length for request and response bodies.") { Argument = new Argument<int>("numBytes", 1000) });
cmd.AddOption(new Option("-maxRequestUriSize", "Max query string length support by the server.") { Argument = new Argument<int>("numChars", 5000) });
cmd.AddOption(new Option("-maxRequestHeaderCount", "Maximum number of headers to place in request") { Argument = new Argument<int>("numHeaders", 90) });
cmd.AddOption(new Option("-maxRequestHeaderTotalSize", "Max request header total size.") { Argument = new Argument<int>("numBytes", 1000) });
cmd.AddOption(new Option("-http", "HTTP version (1.1 or 2.0)") { Argument = new Argument<Version>("version", HttpVersion.Version20) });
cmd.AddOption(new Option("-connectionLifetime", "Max connection lifetime length (milliseconds).") { Argument = new Argument<int?>("connectionLifetime", null) });
cmd.AddOption(new Option("-ops", "Indices of the operations to use") { Argument = new Argument<int[]?>("space-delimited indices", null) });
cmd.AddOption(new Option("-xops", "Indices of the operations to exclude") { Argument = new Argument<int[]?>("space-delimited indices", null) });
cmd.AddOption(new Option("-trace", "Enable System.Net.Http.InternalDiagnostics (client) and/or ASP.NET dignostics (server) tracing.") { Argument = new Argument<bool>("enable", false) });
cmd.AddOption(new Option("-aspnetlog", "Enable ASP.NET warning and error logging.") { Argument = new Argument<bool>("enable", false) });
cmd.AddOption(new Option("-listOps", "List available options.") { Argument = new Argument<bool>("enable", false) });
cmd.AddOption(new Option("-seed", "Seed for generating pseudo-random parameters for a given -n argument.") { Argument = new Argument<int?>("seed", null) });
cmd.AddOption(new Option("-numParameters", "Max number of query parameters or form fields for a request.") { Argument = new Argument<int>("queryParameters", 1) });
cmd.AddOption(new Option("-cancelRate", "Number between 0 and 1 indicating rate of client-side request cancellation attempts. Defaults to 0.1.") { Argument = new Argument<double>("probability", 0.1) });
cmd.AddOption(new Option("-httpSys", "Use http.sys instead of Kestrel.") { Argument = new Argument<bool>("enable", false) });
cmd.AddOption(new Option("-winHttp", "Use WinHttpHandler for the stress client.") { Argument = new Argument<bool>("enable", false) });
cmd.AddOption(new Option("-displayInterval", "Client stats display interval in seconds. Defaults to 5 seconds.") { Argument = new Argument<int>("seconds", 5) });
cmd.AddOption(new Option("-clientTimeout", "Default HttpClient timeout in seconds. Defaults to 60 seconds.") { Argument = new Argument<int>("seconds", 60) });
cmd.AddOption(new Option("-serverMaxConcurrentStreams", "Overrides kestrel max concurrent streams per connection.") { Argument = new Argument<int?>("streams", null) });
cmd.AddOption(new Option("-serverMaxFrameSize", "Overrides kestrel max frame size setting.") { Argument = new Argument<int?>("bytes", null) });
cmd.AddOption(new Option("-serverInitialConnectionWindowSize", "Overrides kestrel initial connection window size setting.") { Argument = new Argument<int?>("bytes", null) });
cmd.AddOption(new Option("-serverMaxRequestHeaderFieldSize", "Overrides kestrel max request header field size.") { Argument = new Argument<int?>("bytes", null) });
ParseResult cmdline = cmd.Parse(args);
if (cmdline.Errors.Count > 0)
{
foreach (ParseError error in cmdline.Errors)
{
Console.WriteLine(error);
}
Console.WriteLine();
new HelpBuilder(new SystemConsole()).Write(cmd);
config = null;
return false;
}
config = new Configuration()
{
RunMode = cmdline.ValueForOption<RunMode>("-runMode"),
ServerUri = cmdline.ValueForOption<string>("-serverUri"),
ListOperations = cmdline.ValueForOption<bool>("-listOps"),
HttpVersion = cmdline.ValueForOption<Version>("-http"),
UseWinHttpHandler = cmdline.ValueForOption<bool>("-winHttp"),
ConcurrentRequests = cmdline.ValueForOption<int>("-n"),
RandomSeed = cmdline.ValueForOption<int?>("-seed") ?? new Random().Next(),
MaxContentLength = cmdline.ValueForOption<int>("-maxContentLength"),
MaxRequestUriSize = cmdline.ValueForOption<int>("-maxRequestUriSize"),
MaxRequestHeaderCount = cmdline.ValueForOption<int>("-maxRequestHeaderCount"),
MaxRequestHeaderTotalSize = cmdline.ValueForOption<int>("-maxRequestHeaderTotalSize"),
OpIndices = cmdline.ValueForOption<int[]>("-ops"),
ExcludedOpIndices = cmdline.ValueForOption<int[]>("-xops"),
MaxParameters = cmdline.ValueForOption<int>("-numParameters"),
DisplayInterval = TimeSpan.FromSeconds(cmdline.ValueForOption<int>("-displayInterval")),
DefaultTimeout = TimeSpan.FromSeconds(cmdline.ValueForOption<int>("-clientTimeout")),
ConnectionLifetime = cmdline.ValueForOption<double?>("-connectionLifetime").Select(TimeSpan.FromMilliseconds),
CancellationProbability = Math.Max(0, Math.Min(1, cmdline.ValueForOption<double>("-cancelRate"))),
MaximumExecutionTime = cmdline.ValueForOption<double?>("-maxExecutionTime").Select(TimeSpan.FromMinutes),
UseHttpSys = cmdline.ValueForOption<bool>("-httpSys"),
LogAspNet = cmdline.ValueForOption<bool>("-aspnetlog"),
Trace = cmdline.ValueForOption<bool>("-trace"),
ServerMaxConcurrentStreams = cmdline.ValueForOption<int?>("-serverMaxConcurrentStreams"),
ServerMaxFrameSize = cmdline.ValueForOption<int?>("-serverMaxFrameSize"),
ServerInitialConnectionWindowSize = cmdline.ValueForOption<int?>("-serverInitialConnectionWindowSize"),
ServerMaxRequestHeaderFieldSize = cmdline.ValueForOption<int?>("-serverMaxRequestHeaderFieldSize"),
};
return true;
}
private static async Task<ExitCode> Run(Configuration config)
{
(string name, Func<RequestContext, Task> op)[] clientOperations =
ClientOperations.Operations
// annotate the operation name with its index
.Select((op, i) => ($"{i.ToString().PadLeft(2)}: {op.name}", op.operation))
.ToArray();
if ((config.RunMode & RunMode.both) == 0)
{
Console.Error.WriteLine("Must specify a valid run mode");
return ExitCode.CliError;
}
if (!config.ServerUri.StartsWith("http"))
{
Console.Error.WriteLine("Invalid server uri");
return ExitCode.CliError;
}
if (config.ListOperations)
{
for (int i = 0; i < clientOperations.Length; i++)
{
Console.WriteLine(clientOperations[i].name);
}
return ExitCode.Success;
}
// derive client operations based on arguments
(string name, Func<RequestContext, Task> op)[] usedClientOperations = (config.OpIndices, config.ExcludedOpIndices) switch
{
(null, null) => clientOperations,
(int[] incl, null) => incl.Select(i => clientOperations[i]).ToArray(),
(_, int[] excl) =>
Enumerable
.Range(0, clientOperations.Length)
.Except(excl)
.Select(i => clientOperations[i])
.ToArray(),
};
string GetAssemblyInfo(Assembly assembly) => $"{assembly.Location}, modified {new FileInfo(assembly.Location).LastWriteTime}";
Console.WriteLine(" .NET Core: " + GetAssemblyInfo(typeof(object).Assembly));
Console.WriteLine(" ASP.NET Core: " + GetAssemblyInfo(typeof(WebHost).Assembly));
Console.WriteLine(" System.Net.Http: " + GetAssemblyInfo(typeof(System.Net.Http.HttpClient).Assembly));
Console.WriteLine(" Server: " + (config.UseHttpSys ? "http.sys" : "Kestrel"));
Console.WriteLine(" Server URL: " + config.ServerUri);
Console.WriteLine(" Client Tracing: " + (config.Trace && config.RunMode.HasFlag(RunMode.client) ? "ON (client.log)" : "OFF"));
Console.WriteLine(" Server Tracing: " + (config.Trace && config.RunMode.HasFlag(RunMode.server) ? "ON (server.log)" : "OFF"));
Console.WriteLine(" ASP.NET Log: " + config.LogAspNet);
Console.WriteLine(" Concurrency: " + config.ConcurrentRequests);
Console.WriteLine(" Content Length: " + config.MaxContentLength);
Console.WriteLine(" HTTP Version: " + config.HttpVersion);
Console.WriteLine(" Lifetime: " + (config.ConnectionLifetime.HasValue ? $"{config.ConnectionLifetime.Value.TotalMilliseconds}ms" : "(infinite)"));
Console.WriteLine(" Operations: " + string.Join(", ", usedClientOperations.Select(o => o.name)));
Console.WriteLine(" Random Seed: " + config.RandomSeed);
Console.WriteLine(" Cancellation: " + 100 * config.CancellationProbability + "%");
Console.WriteLine("Max Content Size: " + config.MaxContentLength);
Console.WriteLine("Query Parameters: " + config.MaxParameters);
Console.WriteLine();
StressServer? server = null;
if (config.RunMode.HasFlag(RunMode.server))
{
// Start the Kestrel web server in-proc.
Console.WriteLine($"Starting {(config.UseHttpSys ? "http.sys" : "Kestrel")} server.");
server = new StressServer(config);
Console.WriteLine($"Server started at {server.ServerUri}");
}
StressClient? client = null;
if (config.RunMode.HasFlag(RunMode.client))
{
// Start the client.
Console.WriteLine($"Starting {config.ConcurrentRequests} client workers.");
client = new StressClient(usedClientOperations, config);
client.Start();
}
await WaitUntilMaxExecutionTimeElapsedOrKeyboardInterrupt(config.MaximumExecutionTime);
client?.Stop();
client?.PrintFinalReport();
// return nonzero status code if there are stress errors
return client?.TotalErrorCount == 0 ? ExitCode.Success : ExitCode.StressError;
}
private static async Task WaitUntilMaxExecutionTimeElapsedOrKeyboardInterrupt(TimeSpan? maxExecutionTime = null)
{
var tcs = new TaskCompletionSource<bool>();
Console.CancelKeyPress += (sender, args) => { Console.Error.WriteLine("Keyboard interrupt"); args.Cancel = true; tcs.TrySetResult(false); };
if (maxExecutionTime.HasValue)
{
Console.WriteLine($"Running for a total of {maxExecutionTime.Value.TotalMinutes:0.##} minutes");
var cts = new System.Threading.CancellationTokenSource(delay: maxExecutionTime.Value);
cts.Token.Register(() => { Console.WriteLine("Max execution time elapsed"); tcs.TrySetResult(false); });
}
await tcs.Task;
}
private static S? Select<T, S>(this T? value, Func<T, S> mapper) where T : struct where S : struct
{
return value is null ? null : new S?(mapper(value.Value));
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Microsoft.AspNetCore;
using System;
using System.Collections.Generic;
using System.CommandLine;
using System.IO;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using System.Net;
using HttpStress;
[assembly:SupportedOSPlatform("windows")]
[assembly:SupportedOSPlatform("linux")]
namespace HttpStress
{
/// <summary>
/// Simple HttpClient stress app that launches Kestrel in-proc and runs many concurrent requests of varying types against it.
/// </summary>
public static class Program
{
public enum ExitCode { Success = 0, StressError = 1, CliError = 2 };
public static async Task<int> Main(string[] args)
{
if (!TryParseCli(args, out Configuration? config))
{
return (int)ExitCode.CliError;
}
return (int)await Run(config);
}
private static bool TryParseCli(string[] args, [NotNullWhen(true)] out Configuration? config)
{
var cmd = new RootCommand();
cmd.AddOption(new Option("-n", "Max number of requests to make concurrently.") { Argument = new Argument<int>("numWorkers", Environment.ProcessorCount) });
cmd.AddOption(new Option("-serverUri", "Stress suite server uri.") { Argument = new Argument<string>("serverUri", "https://localhost:5001") });
cmd.AddOption(new Option("-runMode", "Stress suite execution mode. Defaults to Both.") { Argument = new Argument<RunMode>("runMode", RunMode.both) });
cmd.AddOption(new Option("-maxExecutionTime", "Maximum stress execution time, in minutes. Defaults to infinity.") { Argument = new Argument<double?>("minutes", null) });
cmd.AddOption(new Option("-maxContentLength", "Max content length for request and response bodies.") { Argument = new Argument<int>("numBytes", 1000) });
cmd.AddOption(new Option("-maxRequestUriSize", "Max query string length support by the server.") { Argument = new Argument<int>("numChars", 5000) });
cmd.AddOption(new Option("-maxRequestHeaderCount", "Maximum number of headers to place in request") { Argument = new Argument<int>("numHeaders", 90) });
cmd.AddOption(new Option("-maxRequestHeaderTotalSize", "Max request header total size.") { Argument = new Argument<int>("numBytes", 1000) });
cmd.AddOption(new Option("-http", "HTTP version (1.1 or 2.0)") { Argument = new Argument<Version>("version", HttpVersion.Version20) });
cmd.AddOption(new Option("-connectionLifetime", "Max connection lifetime length (milliseconds).") { Argument = new Argument<int?>("connectionLifetime", null) });
cmd.AddOption(new Option("-ops", "Indices of the operations to use") { Argument = new Argument<int[]?>("space-delimited indices", null) });
cmd.AddOption(new Option("-xops", "Indices of the operations to exclude") { Argument = new Argument<int[]?>("space-delimited indices", null) });
cmd.AddOption(new Option("-trace", "Enable System.Net.Http.InternalDiagnostics (client) and/or ASP.NET dignostics (server) tracing.") { Argument = new Argument<bool>("enable", false) });
cmd.AddOption(new Option("-aspnetlog", "Enable ASP.NET warning and error logging.") { Argument = new Argument<bool>("enable", false) });
cmd.AddOption(new Option("-listOps", "List available options.") { Argument = new Argument<bool>("enable", false) });
cmd.AddOption(new Option("-seed", "Seed for generating pseudo-random parameters for a given -n argument.") { Argument = new Argument<int?>("seed", null) });
cmd.AddOption(new Option("-numParameters", "Max number of query parameters or form fields for a request.") { Argument = new Argument<int>("queryParameters", 1) });
cmd.AddOption(new Option("-cancelRate", "Number between 0 and 1 indicating rate of client-side request cancellation attempts. Defaults to 0.1.") { Argument = new Argument<double>("probability", 0.1) });
cmd.AddOption(new Option("-httpSys", "Use http.sys instead of Kestrel.") { Argument = new Argument<bool>("enable", false) });
cmd.AddOption(new Option("-winHttp", "Use WinHttpHandler for the stress client.") { Argument = new Argument<bool>("enable", false) });
cmd.AddOption(new Option("-displayInterval", "Client stats display interval in seconds. Defaults to 5 seconds.") { Argument = new Argument<int>("seconds", 5) });
cmd.AddOption(new Option("-clientTimeout", "Default HttpClient timeout in seconds. Defaults to 60 seconds.") { Argument = new Argument<int>("seconds", 60) });
cmd.AddOption(new Option("-serverMaxConcurrentStreams", "Overrides kestrel max concurrent streams per connection.") { Argument = new Argument<int?>("streams", null) });
cmd.AddOption(new Option("-serverMaxFrameSize", "Overrides kestrel max frame size setting.") { Argument = new Argument<int?>("bytes", null) });
cmd.AddOption(new Option("-serverInitialConnectionWindowSize", "Overrides kestrel initial connection window size setting.") { Argument = new Argument<int?>("bytes", null) });
cmd.AddOption(new Option("-serverMaxRequestHeaderFieldSize", "Overrides kestrel max request header field size.") { Argument = new Argument<int?>("bytes", null) });
ParseResult cmdline = cmd.Parse(args);
if (cmdline.Errors.Count > 0)
{
foreach (ParseError error in cmdline.Errors)
{
Console.WriteLine(error);
}
Console.WriteLine();
new HelpBuilder(new SystemConsole()).Write(cmd);
config = null;
return false;
}
config = new Configuration()
{
RunMode = cmdline.ValueForOption<RunMode>("-runMode"),
ServerUri = cmdline.ValueForOption<string>("-serverUri"),
ListOperations = cmdline.ValueForOption<bool>("-listOps"),
HttpVersion = cmdline.ValueForOption<Version>("-http"),
UseWinHttpHandler = cmdline.ValueForOption<bool>("-winHttp"),
ConcurrentRequests = cmdline.ValueForOption<int>("-n"),
RandomSeed = cmdline.ValueForOption<int?>("-seed") ?? new Random().Next(),
MaxContentLength = cmdline.ValueForOption<int>("-maxContentLength"),
MaxRequestUriSize = cmdline.ValueForOption<int>("-maxRequestUriSize"),
MaxRequestHeaderCount = cmdline.ValueForOption<int>("-maxRequestHeaderCount"),
MaxRequestHeaderTotalSize = cmdline.ValueForOption<int>("-maxRequestHeaderTotalSize"),
OpIndices = cmdline.ValueForOption<int[]>("-ops"),
ExcludedOpIndices = cmdline.ValueForOption<int[]>("-xops"),
MaxParameters = cmdline.ValueForOption<int>("-numParameters"),
DisplayInterval = TimeSpan.FromSeconds(cmdline.ValueForOption<int>("-displayInterval")),
DefaultTimeout = TimeSpan.FromSeconds(cmdline.ValueForOption<int>("-clientTimeout")),
ConnectionLifetime = cmdline.ValueForOption<double?>("-connectionLifetime").Select(TimeSpan.FromMilliseconds),
CancellationProbability = Math.Max(0, Math.Min(1, cmdline.ValueForOption<double>("-cancelRate"))),
MaximumExecutionTime = cmdline.ValueForOption<double?>("-maxExecutionTime").Select(TimeSpan.FromMinutes),
UseHttpSys = cmdline.ValueForOption<bool>("-httpSys"),
LogAspNet = cmdline.ValueForOption<bool>("-aspnetlog"),
Trace = cmdline.ValueForOption<bool>("-trace"),
ServerMaxConcurrentStreams = cmdline.ValueForOption<int?>("-serverMaxConcurrentStreams"),
ServerMaxFrameSize = cmdline.ValueForOption<int?>("-serverMaxFrameSize"),
ServerInitialConnectionWindowSize = cmdline.ValueForOption<int?>("-serverInitialConnectionWindowSize"),
ServerMaxRequestHeaderFieldSize = cmdline.ValueForOption<int?>("-serverMaxRequestHeaderFieldSize"),
};
return true;
}
private static async Task<ExitCode> Run(Configuration config)
{
(string name, Func<RequestContext, Task> op)[] clientOperations =
ClientOperations.Operations
// annotate the operation name with its index
.Select((op, i) => ($"{i.ToString().PadLeft(2)}: {op.name}", op.operation))
.ToArray();
if ((config.RunMode & RunMode.both) == 0)
{
Console.Error.WriteLine("Must specify a valid run mode");
return ExitCode.CliError;
}
if (!config.ServerUri.StartsWith("http"))
{
Console.Error.WriteLine("Invalid server uri");
return ExitCode.CliError;
}
if (config.ListOperations)
{
for (int i = 0; i < clientOperations.Length; i++)
{
Console.WriteLine(clientOperations[i].name);
}
return ExitCode.Success;
}
// derive client operations based on arguments
(string name, Func<RequestContext, Task> op)[] usedClientOperations = (config.OpIndices, config.ExcludedOpIndices) switch
{
(null, null) => clientOperations,
(int[] incl, null) => incl.Select(i => clientOperations[i]).ToArray(),
(_, int[] excl) =>
Enumerable
.Range(0, clientOperations.Length)
.Except(excl)
.Select(i => clientOperations[i])
.ToArray(),
};
string GetAssemblyInfo(Assembly assembly) => $"{assembly.Location}, modified {new FileInfo(assembly.Location).LastWriteTime}";
Console.WriteLine(" .NET Core: " + GetAssemblyInfo(typeof(object).Assembly));
Console.WriteLine(" ASP.NET Core: " + GetAssemblyInfo(typeof(WebHost).Assembly));
Console.WriteLine(" System.Net.Http: " + GetAssemblyInfo(typeof(System.Net.Http.HttpClient).Assembly));
Console.WriteLine(" Server: " + (config.UseHttpSys ? "http.sys" : "Kestrel"));
Console.WriteLine(" Server URL: " + config.ServerUri);
Console.WriteLine(" Client Tracing: " + (config.Trace && config.RunMode.HasFlag(RunMode.client) ? "ON (client.log)" : "OFF"));
Console.WriteLine(" Server Tracing: " + (config.Trace && config.RunMode.HasFlag(RunMode.server) ? "ON (server.log)" : "OFF"));
Console.WriteLine(" ASP.NET Log: " + config.LogAspNet);
Console.WriteLine(" Concurrency: " + config.ConcurrentRequests);
Console.WriteLine(" Content Length: " + config.MaxContentLength);
Console.WriteLine(" HTTP Version: " + config.HttpVersion);
Console.WriteLine(" Lifetime: " + (config.ConnectionLifetime.HasValue ? $"{config.ConnectionLifetime.Value.TotalMilliseconds}ms" : "(infinite)"));
Console.WriteLine(" Operations: " + string.Join(", ", usedClientOperations.Select(o => o.name)));
Console.WriteLine(" Random Seed: " + config.RandomSeed);
Console.WriteLine(" Cancellation: " + 100 * config.CancellationProbability + "%");
Console.WriteLine("Max Content Size: " + config.MaxContentLength);
Console.WriteLine("Query Parameters: " + config.MaxParameters);
Console.WriteLine();
StressServer? server = null;
if (config.RunMode.HasFlag(RunMode.server))
{
// Start the Kestrel web server in-proc.
Console.WriteLine($"Starting {(config.UseHttpSys ? "http.sys" : "Kestrel")} server.");
server = new StressServer(config);
Console.WriteLine($"Server started at {server.ServerUri}");
}
StressClient? client = null;
if (config.RunMode.HasFlag(RunMode.client))
{
// Start the client.
Console.WriteLine($"Starting {config.ConcurrentRequests} client workers.");
client = new StressClient(usedClientOperations, config);
client.Start();
}
await WaitUntilMaxExecutionTimeElapsedOrKeyboardInterrupt(config.MaximumExecutionTime);
client?.Stop();
client?.PrintFinalReport();
// return nonzero status code if there are stress errors
return client?.TotalErrorCount == 0 ? ExitCode.Success : ExitCode.StressError;
}
private static async Task WaitUntilMaxExecutionTimeElapsedOrKeyboardInterrupt(TimeSpan? maxExecutionTime = null)
{
var tcs = new TaskCompletionSource<bool>();
Console.CancelKeyPress += (sender, args) => { Console.Error.WriteLine("Keyboard interrupt"); args.Cancel = true; tcs.TrySetResult(false); };
if (maxExecutionTime.HasValue)
{
Console.WriteLine($"Running for a total of {maxExecutionTime.Value.TotalMinutes:0.##} minutes");
var cts = new System.Threading.CancellationTokenSource(delay: maxExecutionTime.Value);
cts.Token.Register(() => { Console.WriteLine("Max execution time elapsed"); tcs.TrySetResult(false); });
}
await tcs.Task;
}
private static S? Select<T, S>(this T? value, Func<T, S> mapper) where T : struct where S : struct
{
return value is null ? null : new S?(mapper(value.Value));
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Globalization/tests/NumberFormatInfo/NumberFormatInfoCurrencyDecimalDigits.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using Xunit;
namespace System.Globalization.Tests
{
public class NumberFormatInfoCurrencyDecimalDigits
{
public static IEnumerable<object[]> CurrencyDecimalDigits_TestData()
{
yield return new object[] { NumberFormatInfo.InvariantInfo, 2, 2 };
yield return new object[] { CultureInfo.GetCultureInfo("en-US").NumberFormat, 2, 2 };
yield return new object[] { CultureInfo.GetCultureInfo("ko").NumberFormat, 0, 2 };
}
[Theory]
[MemberData(nameof(CurrencyDecimalDigits_TestData))]
public void CurrencyDecimalDigits_Get_ReturnsExpected(NumberFormatInfo format, int expectedNls, int expectedIcu)
{
int expected = PlatformDetection.IsNlsGlobalization ? expectedNls : expectedIcu;
Assert.Equal(expected, format.CurrencyDecimalDigits);
}
[Theory]
[InlineData(0)]
[InlineData(1)]
[InlineData(99)]
public void CurrencyDecimalDigits_Set_GetReturnsExpected(int newCurrencyDecimalDigits)
{
NumberFormatInfo format = new NumberFormatInfo();
format.CurrencyDecimalDigits = newCurrencyDecimalDigits;
Assert.Equal(newCurrencyDecimalDigits, format.CurrencyDecimalDigits);
}
[Theory]
[InlineData(-1)]
[InlineData(100)]
public void CurrencyDecimalDigits_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
{
var format = new NumberFormatInfo();
AssertExtensions.Throws<ArgumentOutOfRangeException>("value", "CurrencyDecimalDigits", () => format.CurrencyDecimalDigits = value);
}
[Fact]
public void CurrencyDecimalDigits_SetReadOnly_ThrowsInvalidOperationException()
{
Assert.Throws<InvalidOperationException>(() => NumberFormatInfo.InvariantInfo.CurrencyDecimalDigits = 2);
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using Xunit;
namespace System.Globalization.Tests
{
public class NumberFormatInfoCurrencyDecimalDigits
{
public static IEnumerable<object[]> CurrencyDecimalDigits_TestData()
{
yield return new object[] { NumberFormatInfo.InvariantInfo, 2, 2 };
yield return new object[] { CultureInfo.GetCultureInfo("en-US").NumberFormat, 2, 2 };
yield return new object[] { CultureInfo.GetCultureInfo("ko").NumberFormat, 0, 2 };
}
[Theory]
[MemberData(nameof(CurrencyDecimalDigits_TestData))]
public void CurrencyDecimalDigits_Get_ReturnsExpected(NumberFormatInfo format, int expectedNls, int expectedIcu)
{
int expected = PlatformDetection.IsNlsGlobalization ? expectedNls : expectedIcu;
Assert.Equal(expected, format.CurrencyDecimalDigits);
}
[Theory]
[InlineData(0)]
[InlineData(1)]
[InlineData(99)]
public void CurrencyDecimalDigits_Set_GetReturnsExpected(int newCurrencyDecimalDigits)
{
NumberFormatInfo format = new NumberFormatInfo();
format.CurrencyDecimalDigits = newCurrencyDecimalDigits;
Assert.Equal(newCurrencyDecimalDigits, format.CurrencyDecimalDigits);
}
[Theory]
[InlineData(-1)]
[InlineData(100)]
public void CurrencyDecimalDigits_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
{
var format = new NumberFormatInfo();
AssertExtensions.Throws<ArgumentOutOfRangeException>("value", "CurrencyDecimalDigits", () => format.CurrencyDecimalDigits = value);
}
[Fact]
public void CurrencyDecimalDigits_SetReadOnly_ThrowsInvalidOperationException()
{
Assert.Throws<InvalidOperationException>(() => NumberFormatInfo.InvariantInfo.CurrencyDecimalDigits = 2);
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.ServiceProcess.ServiceController/tests/System.ServiceProcess.ServiceController.TestService/Program.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Threading;
namespace System.ServiceProcess.Tests
{
public class Program
{
static int Main(string[] args)
{
Thread.CurrentThread.Name = "Test Service";
if (args.Length == 1 || args.Length == 2)
{
TestService testService;
if (args[0].StartsWith("PropagateExceptionFromOnStart"))
{
var expectedException = new InvalidOperationException("Fail on startup.");
testService = new TestService(args[0], expectedException);
try
{
ServiceBase.Run(testService);
}
catch (Exception actualException)
{
if (object.ReferenceEquals(expectedException, actualException))
{
testService.WriteStreamAsync(PipeMessageByteCode.ExceptionThrown).Wait();
}
else
{
throw actualException;
}
}
}
else if (args[0].StartsWith("LogWritten"))
{
testService = new TestService(args[0], throwException: null);
testService.AutoLog = false;
ServiceBase.Run(testService);
}
else
{
testService = new TestService(args[0]);
ServiceBase.Run(testService);
}
return 0;
}
else if (args.Length == 3)
{
TestServiceInstaller testServiceInstaller = new TestServiceInstaller();
testServiceInstaller.ServiceName = args[0];
testServiceInstaller.DisplayName = args[1];
if (args[2] == "create")
{
testServiceInstaller.Install();
return 0;
}
else if (args[2] == "delete")
{
testServiceInstaller.RemoveService();
return 0;
}
else
{
Console.WriteLine("EROOR: Invalid Service verb. Only suppot create or delete.");
return 2;
}
}
Console.WriteLine($"usage: <ServiceName> <DisplayName> [create|delete]");
return 1;
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Threading;
namespace System.ServiceProcess.Tests
{
public class Program
{
static int Main(string[] args)
{
Thread.CurrentThread.Name = "Test Service";
if (args.Length == 1 || args.Length == 2)
{
TestService testService;
if (args[0].StartsWith("PropagateExceptionFromOnStart"))
{
var expectedException = new InvalidOperationException("Fail on startup.");
testService = new TestService(args[0], expectedException);
try
{
ServiceBase.Run(testService);
}
catch (Exception actualException)
{
if (object.ReferenceEquals(expectedException, actualException))
{
testService.WriteStreamAsync(PipeMessageByteCode.ExceptionThrown).Wait();
}
else
{
throw actualException;
}
}
}
else if (args[0].StartsWith("LogWritten"))
{
testService = new TestService(args[0], throwException: null);
testService.AutoLog = false;
ServiceBase.Run(testService);
}
else
{
testService = new TestService(args[0]);
ServiceBase.Run(testService);
}
return 0;
}
else if (args.Length == 3)
{
TestServiceInstaller testServiceInstaller = new TestServiceInstaller();
testServiceInstaller.ServiceName = args[0];
testServiceInstaller.DisplayName = args[1];
if (args[2] == "create")
{
testServiceInstaller.Install();
return 0;
}
else if (args[2] == "delete")
{
testServiceInstaller.RemoveService();
return 0;
}
else
{
Console.WriteLine("EROOR: Invalid Service verb. Only suppot create or delete.");
return 2;
}
}
Console.WriteLine($"usage: <ServiceName> <DisplayName> [create|delete]");
return 1;
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/Math/Functions/Double/MaxDouble.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
namespace System.MathBenchmarks
{
public partial class Double
{
// Tests Math.Min(double) over 5000 iterations for the domain -1, +1
private const double maxDelta = 0.0004;
private const double maxExpectedResult = -1.0;
public void Max() => MaxTest();
public static void MaxTest()
{
double result = 0.0, val1 = -1.0, val2 = -1.0 - maxDelta;
for (int iteration = 0; iteration < MathTests.Iterations; iteration++)
{
val2 += maxDelta;
result += Math.Max(val1, val2);
}
double diff = Math.Abs(maxExpectedResult - result);
if (diff > MathTests.DoubleEpsilon)
{
throw new Exception($"Expected Result {maxExpectedResult,20:g17}; Actual Result {result,20:g17}");
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
namespace System.MathBenchmarks
{
public partial class Double
{
// Tests Math.Min(double) over 5000 iterations for the domain -1, +1
private const double maxDelta = 0.0004;
private const double maxExpectedResult = -1.0;
public void Max() => MaxTest();
public static void MaxTest()
{
double result = 0.0, val1 = -1.0, val2 = -1.0 - maxDelta;
for (int iteration = 0; iteration < MathTests.Iterations; iteration++)
{
val2 += maxDelta;
result += Math.Max(val1, val2);
}
double diff = Math.Abs(maxExpectedResult - result);
if (diff > MathTests.DoubleEpsilon)
{
throw new Exception($"Expected Result {maxExpectedResult,20:g17}; Actual Result {result,20:g17}");
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/Directed/cmov/Bool_And_Op.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
#pragma warning disable
using System;
class testout1
{
static bool static_field_bool;
static bool sfb_false;
static bool sfb_true;
bool mfb;
bool mfb_false;
bool mfb_true;
static bool simple_func_bool()
{
return true;
}
static bool func_sb_true()
{
return true;
}
static bool func_sb_false()
{
return false;
}
static int Sub_Funclet_0()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && true ? true : true) True_Sum++; else False_Sum++;
if (true && true ? true : false) True_Sum++; else False_Sum++;
if (true && true ? true : local_bool) True_Sum++; else False_Sum++;
if (true && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? false : true) True_Sum++; else False_Sum++;
if (true && true ? false : false) True_Sum++; else False_Sum++;
if (true && true ? false : local_bool) True_Sum++; else False_Sum++;
if (true && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? local_bool : true) True_Sum++; else False_Sum++;
if (true && true ? local_bool : false) True_Sum++; else False_Sum++;
if (true && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_1()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_2()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_3()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? true : true) True_Sum++; else False_Sum++;
if (true && false ? true : false) True_Sum++; else False_Sum++;
if (true && false ? true : local_bool) True_Sum++; else False_Sum++;
if (true && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? false : true) True_Sum++; else False_Sum++;
if (true && false ? false : false) True_Sum++; else False_Sum++;
if (true && false ? false : local_bool) True_Sum++; else False_Sum++;
if (true && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_4()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && false ? local_bool : true) True_Sum++; else False_Sum++;
if (true && false ? local_bool : false) True_Sum++; else False_Sum++;
if (true && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_5()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_6()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? true : true) True_Sum++; else False_Sum++;
if (true && lb_true ? true : false) True_Sum++; else False_Sum++;
if (true && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? false : true) True_Sum++; else False_Sum++;
if (true && lb_true ? false : false) True_Sum++; else False_Sum++;
if (true && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_7()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_8()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_9()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? true : true) True_Sum++; else False_Sum++;
if (true && lb_false ? true : false) True_Sum++; else False_Sum++;
if (true && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_10()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_false ? false : true) True_Sum++; else False_Sum++;
if (true && lb_false ? false : false) True_Sum++; else False_Sum++;
if (true && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_11()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_12()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_13()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_14()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_15()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_16()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_17()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_18()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_19()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_20()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_21()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_22()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_23()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_24()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_25()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_26()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_27()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_28()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_29()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_30()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_31()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_32()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_33()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_34()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_35()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_36()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_37()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_38()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? true : true) True_Sum++; else False_Sum++;
if (false && true ? true : false) True_Sum++; else False_Sum++;
if (false && true ? true : local_bool) True_Sum++; else False_Sum++;
if (false && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? false : true) True_Sum++; else False_Sum++;
if (false && true ? false : false) True_Sum++; else False_Sum++;
if (false && true ? false : local_bool) True_Sum++; else False_Sum++;
if (false && true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_39()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? local_bool : true) True_Sum++; else False_Sum++;
if (false && true ? local_bool : false) True_Sum++; else False_Sum++;
if (false && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_40()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_41()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? true : true) True_Sum++; else False_Sum++;
if (false && false ? true : false) True_Sum++; else False_Sum++;
if (false && false ? true : local_bool) True_Sum++; else False_Sum++;
if (false && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_42()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && false ? false : true) True_Sum++; else False_Sum++;
if (false && false ? false : false) True_Sum++; else False_Sum++;
if (false && false ? false : local_bool) True_Sum++; else False_Sum++;
if (false && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? local_bool : true) True_Sum++; else False_Sum++;
if (false && false ? local_bool : false) True_Sum++; else False_Sum++;
if (false && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_43()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_44()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? true : true) True_Sum++; else False_Sum++;
if (false && lb_true ? true : false) True_Sum++; else False_Sum++;
if (false && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_45()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? false : true) True_Sum++; else False_Sum++;
if (false && lb_true ? false : false) True_Sum++; else False_Sum++;
if (false && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_46()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_47()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_48()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_false ? true : true) True_Sum++; else False_Sum++;
if (false && lb_false ? true : false) True_Sum++; else False_Sum++;
if (false && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? false : true) True_Sum++; else False_Sum++;
if (false && lb_false ? false : false) True_Sum++; else False_Sum++;
if (false && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_49()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_50()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_51()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_52()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_53()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_54()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_55()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_56()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_57()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_58()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_59()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_60()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_61()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_62()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_63()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_64()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_65()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_66()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_67()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_68()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_69()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_70()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_71()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_72()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_73()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_74()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_75()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_76()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? true : true) True_Sum++; else False_Sum++;
if (lb_true && true ? true : false) True_Sum++; else False_Sum++;
if (lb_true && true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_77()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? false : true) True_Sum++; else False_Sum++;
if (lb_true && true ? false : false) True_Sum++; else False_Sum++;
if (lb_true && true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_78()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_79()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_80()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && false ? true : true) True_Sum++; else False_Sum++;
if (lb_true && false ? true : false) True_Sum++; else False_Sum++;
if (lb_true && false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? false : true) True_Sum++; else False_Sum++;
if (lb_true && false ? false : false) True_Sum++; else False_Sum++;
if (lb_true && false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_81()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_82()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_83()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_84()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_85()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_86()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_87()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_88()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_89()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_90()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_91()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_92()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_93()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_94()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_95()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_96()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_97()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_98()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_99()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_100()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_101()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_102()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_103()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_104()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_105()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_106()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_107()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_108()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_109()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_110()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_111()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_112()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_113()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_114()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_115()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? true : true) True_Sum++; else False_Sum++;
if (lb_false && true ? true : false) True_Sum++; else False_Sum++;
if (lb_false && true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? false : true) True_Sum++; else False_Sum++;
if (lb_false && true ? false : false) True_Sum++; else False_Sum++;
if (lb_false && true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_116()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_117()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_118()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? true : true) True_Sum++; else False_Sum++;
if (lb_false && false ? true : false) True_Sum++; else False_Sum++;
if (lb_false && false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? false : true) True_Sum++; else False_Sum++;
if (lb_false && false ? false : false) True_Sum++; else False_Sum++;
if (lb_false && false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_119()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_120()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_121()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_122()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_123()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_124()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_125()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_126()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_127()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_128()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_129()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_130()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_131()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_132()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_133()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_134()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_135()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_136()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_137()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_138()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_139()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_140()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_141()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_142()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_143()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_144()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_145()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_146()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_147()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_148()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_149()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_150()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_151()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_152()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_153()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_154()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && true ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_155()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_156()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_157()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_158()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_159()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_160()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_161()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_162()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_163()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_164()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_165()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_166()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_167()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_168()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_169()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_170()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_171()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_172()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_173()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_174()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_175()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_176()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_177()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_178()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_179()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_180()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_181()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_182()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_183()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_184()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_185()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_186()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_187()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_188()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_189()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_190()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_191()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_192()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && true ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_193()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_194()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_195()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_196()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_197()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_198()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_199()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_200()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_201()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_202()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_203()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_204()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_205()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_206()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_207()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_208()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_209()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_210()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_211()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_212()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_213()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_214()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_215()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_216()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_217()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_218()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_219()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_220()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_221()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_222()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_223()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_224()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_225()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_226()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_227()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_228()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_229()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_230()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_231()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_232()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_233()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_234()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_235()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_236()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_237()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_238()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_239()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_240()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_241()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_242()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_243()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_244()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_245()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_246()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_247()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_248()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_249()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_250()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_251()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_252()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_253()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_254()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_255()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_256()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_257()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_258()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_259()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_260()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_261()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_262()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_263()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_264()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_265()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_266()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_267()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_268()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_269()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_270()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_271()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_272()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_273()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_274()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_275()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_276()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_277()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_278()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_279()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_280()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_281()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_282()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_283()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_284()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_285()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_286()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_287()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_288()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_289()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_290()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_291()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_292()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_293()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_294()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_295()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_296()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_297()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_298()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_299()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_300()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_301()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_302()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_303()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_304()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_305()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_306()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_307()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_308()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_309()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_310()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_311()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_312()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_313()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_314()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_315()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_316()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_317()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_318()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_319()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_320()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_321()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_322()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_323()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_324()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_325()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_326()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_327()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_328()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_329()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_330()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_331()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_332()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_333()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_334()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_335()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_336()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_337()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_338()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_339()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_340()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_341()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_342()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_343()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_344()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_345()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_346()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_347()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_348()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_349()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_350()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_351()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_352()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_353()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_354()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_355()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_356()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_357()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_358()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_359()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_360()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_361()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_362()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_363()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_364()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_365()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_366()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_367()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_368()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_369()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_370()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_371()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_372()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_373()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_374()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_375()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_376()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_377()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_378()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_379()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_380()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_381()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_382()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_383()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_384()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && true ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_385()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_386()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_387()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_388()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_389()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_390()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_391()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_392()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_393()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_394()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_395()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_396()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_397()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_398()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_399()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_400()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_401()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_402()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_403()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_404()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_405()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_406()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_407()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_408()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_409()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_410()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_411()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_412()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_413()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_414()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_415()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_416()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_417()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_418()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_419()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_420()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_421()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_422()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_423()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_424()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_425()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_426()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && false ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_427()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_428()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_429()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_430()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_431()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_432()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_433()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_434()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_435()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_436()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_437()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_438()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_439()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_440()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_441()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_442()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_443()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_444()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_445()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_446()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_447()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_448()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_449()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_450()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_451()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_452()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_453()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_454()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_455()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_456()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_457()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_458()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_459()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_460()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
public static int Main()
{
int Sum = 0;
Sum += Sub_Funclet_0();
Sum += Sub_Funclet_1();
Sum += Sub_Funclet_2();
Sum += Sub_Funclet_3();
Sum += Sub_Funclet_4();
Sum += Sub_Funclet_5();
Sum += Sub_Funclet_6();
Sum += Sub_Funclet_7();
Sum += Sub_Funclet_8();
Sum += Sub_Funclet_9();
Sum += Sub_Funclet_10();
Sum += Sub_Funclet_11();
Sum += Sub_Funclet_12();
Sum += Sub_Funclet_13();
Sum += Sub_Funclet_14();
Sum += Sub_Funclet_15();
Sum += Sub_Funclet_16();
Sum += Sub_Funclet_17();
Sum += Sub_Funclet_18();
Sum += Sub_Funclet_19();
Sum += Sub_Funclet_20();
Sum += Sub_Funclet_21();
Sum += Sub_Funclet_22();
Sum += Sub_Funclet_23();
Sum += Sub_Funclet_24();
Sum += Sub_Funclet_25();
Sum += Sub_Funclet_26();
Sum += Sub_Funclet_27();
Sum += Sub_Funclet_28();
Sum += Sub_Funclet_29();
Sum += Sub_Funclet_30();
Sum += Sub_Funclet_31();
Sum += Sub_Funclet_32();
Sum += Sub_Funclet_33();
Sum += Sub_Funclet_34();
Sum += Sub_Funclet_35();
Sum += Sub_Funclet_36();
Sum += Sub_Funclet_37();
Sum += Sub_Funclet_38();
Sum += Sub_Funclet_39();
Sum += Sub_Funclet_40();
Sum += Sub_Funclet_41();
Sum += Sub_Funclet_42();
Sum += Sub_Funclet_43();
Sum += Sub_Funclet_44();
Sum += Sub_Funclet_45();
Sum += Sub_Funclet_46();
Sum += Sub_Funclet_47();
Sum += Sub_Funclet_48();
Sum += Sub_Funclet_49();
Sum += Sub_Funclet_50();
Sum += Sub_Funclet_51();
Sum += Sub_Funclet_52();
Sum += Sub_Funclet_53();
Sum += Sub_Funclet_54();
Sum += Sub_Funclet_55();
Sum += Sub_Funclet_56();
Sum += Sub_Funclet_57();
Sum += Sub_Funclet_58();
Sum += Sub_Funclet_59();
Sum += Sub_Funclet_60();
Sum += Sub_Funclet_61();
Sum += Sub_Funclet_62();
Sum += Sub_Funclet_63();
Sum += Sub_Funclet_64();
Sum += Sub_Funclet_65();
Sum += Sub_Funclet_66();
Sum += Sub_Funclet_67();
Sum += Sub_Funclet_68();
Sum += Sub_Funclet_69();
Sum += Sub_Funclet_70();
Sum += Sub_Funclet_71();
Sum += Sub_Funclet_72();
Sum += Sub_Funclet_73();
Sum += Sub_Funclet_74();
Sum += Sub_Funclet_75();
Sum += Sub_Funclet_76();
Sum += Sub_Funclet_77();
Sum += Sub_Funclet_78();
Sum += Sub_Funclet_79();
Sum += Sub_Funclet_80();
Sum += Sub_Funclet_81();
Sum += Sub_Funclet_82();
Sum += Sub_Funclet_83();
Sum += Sub_Funclet_84();
Sum += Sub_Funclet_85();
Sum += Sub_Funclet_86();
Sum += Sub_Funclet_87();
Sum += Sub_Funclet_88();
Sum += Sub_Funclet_89();
Sum += Sub_Funclet_90();
Sum += Sub_Funclet_91();
Sum += Sub_Funclet_92();
Sum += Sub_Funclet_93();
Sum += Sub_Funclet_94();
Sum += Sub_Funclet_95();
Sum += Sub_Funclet_96();
Sum += Sub_Funclet_97();
Sum += Sub_Funclet_98();
Sum += Sub_Funclet_99();
Sum += Sub_Funclet_100();
Sum += Sub_Funclet_101();
Sum += Sub_Funclet_102();
Sum += Sub_Funclet_103();
Sum += Sub_Funclet_104();
Sum += Sub_Funclet_105();
Sum += Sub_Funclet_106();
Sum += Sub_Funclet_107();
Sum += Sub_Funclet_108();
Sum += Sub_Funclet_109();
Sum += Sub_Funclet_110();
Sum += Sub_Funclet_111();
Sum += Sub_Funclet_112();
Sum += Sub_Funclet_113();
Sum += Sub_Funclet_114();
Sum += Sub_Funclet_115();
Sum += Sub_Funclet_116();
Sum += Sub_Funclet_117();
Sum += Sub_Funclet_118();
Sum += Sub_Funclet_119();
Sum += Sub_Funclet_120();
Sum += Sub_Funclet_121();
Sum += Sub_Funclet_122();
Sum += Sub_Funclet_123();
Sum += Sub_Funclet_124();
Sum += Sub_Funclet_125();
Sum += Sub_Funclet_126();
Sum += Sub_Funclet_127();
Sum += Sub_Funclet_128();
Sum += Sub_Funclet_129();
Sum += Sub_Funclet_130();
Sum += Sub_Funclet_131();
Sum += Sub_Funclet_132();
Sum += Sub_Funclet_133();
Sum += Sub_Funclet_134();
Sum += Sub_Funclet_135();
Sum += Sub_Funclet_136();
Sum += Sub_Funclet_137();
Sum += Sub_Funclet_138();
Sum += Sub_Funclet_139();
Sum += Sub_Funclet_140();
Sum += Sub_Funclet_141();
Sum += Sub_Funclet_142();
Sum += Sub_Funclet_143();
Sum += Sub_Funclet_144();
Sum += Sub_Funclet_145();
Sum += Sub_Funclet_146();
Sum += Sub_Funclet_147();
Sum += Sub_Funclet_148();
Sum += Sub_Funclet_149();
Sum += Sub_Funclet_150();
Sum += Sub_Funclet_151();
Sum += Sub_Funclet_152();
Sum += Sub_Funclet_153();
Sum += Sub_Funclet_154();
Sum += Sub_Funclet_155();
Sum += Sub_Funclet_156();
Sum += Sub_Funclet_157();
Sum += Sub_Funclet_158();
Sum += Sub_Funclet_159();
Sum += Sub_Funclet_160();
Sum += Sub_Funclet_161();
Sum += Sub_Funclet_162();
Sum += Sub_Funclet_163();
Sum += Sub_Funclet_164();
Sum += Sub_Funclet_165();
Sum += Sub_Funclet_166();
Sum += Sub_Funclet_167();
Sum += Sub_Funclet_168();
Sum += Sub_Funclet_169();
Sum += Sub_Funclet_170();
Sum += Sub_Funclet_171();
Sum += Sub_Funclet_172();
Sum += Sub_Funclet_173();
Sum += Sub_Funclet_174();
Sum += Sub_Funclet_175();
Sum += Sub_Funclet_176();
Sum += Sub_Funclet_177();
Sum += Sub_Funclet_178();
Sum += Sub_Funclet_179();
Sum += Sub_Funclet_180();
Sum += Sub_Funclet_181();
Sum += Sub_Funclet_182();
Sum += Sub_Funclet_183();
Sum += Sub_Funclet_184();
Sum += Sub_Funclet_185();
Sum += Sub_Funclet_186();
Sum += Sub_Funclet_187();
Sum += Sub_Funclet_188();
Sum += Sub_Funclet_189();
Sum += Sub_Funclet_190();
Sum += Sub_Funclet_191();
Sum += Sub_Funclet_192();
Sum += Sub_Funclet_193();
Sum += Sub_Funclet_194();
Sum += Sub_Funclet_195();
Sum += Sub_Funclet_196();
Sum += Sub_Funclet_197();
Sum += Sub_Funclet_198();
Sum += Sub_Funclet_199();
Sum += Sub_Funclet_200();
Sum += Sub_Funclet_201();
Sum += Sub_Funclet_202();
Sum += Sub_Funclet_203();
Sum += Sub_Funclet_204();
Sum += Sub_Funclet_205();
Sum += Sub_Funclet_206();
Sum += Sub_Funclet_207();
Sum += Sub_Funclet_208();
Sum += Sub_Funclet_209();
Sum += Sub_Funclet_210();
Sum += Sub_Funclet_211();
Sum += Sub_Funclet_212();
Sum += Sub_Funclet_213();
Sum += Sub_Funclet_214();
Sum += Sub_Funclet_215();
Sum += Sub_Funclet_216();
Sum += Sub_Funclet_217();
Sum += Sub_Funclet_218();
Sum += Sub_Funclet_219();
Sum += Sub_Funclet_220();
Sum += Sub_Funclet_221();
Sum += Sub_Funclet_222();
Sum += Sub_Funclet_223();
Sum += Sub_Funclet_224();
Sum += Sub_Funclet_225();
Sum += Sub_Funclet_226();
Sum += Sub_Funclet_227();
Sum += Sub_Funclet_228();
Sum += Sub_Funclet_229();
Sum += Sub_Funclet_230();
Sum += Sub_Funclet_231();
Sum += Sub_Funclet_232();
Sum += Sub_Funclet_233();
Sum += Sub_Funclet_234();
Sum += Sub_Funclet_235();
Sum += Sub_Funclet_236();
Sum += Sub_Funclet_237();
Sum += Sub_Funclet_238();
Sum += Sub_Funclet_239();
Sum += Sub_Funclet_240();
Sum += Sub_Funclet_241();
Sum += Sub_Funclet_242();
Sum += Sub_Funclet_243();
Sum += Sub_Funclet_244();
Sum += Sub_Funclet_245();
Sum += Sub_Funclet_246();
Sum += Sub_Funclet_247();
Sum += Sub_Funclet_248();
Sum += Sub_Funclet_249();
Sum += Sub_Funclet_250();
Sum += Sub_Funclet_251();
Sum += Sub_Funclet_252();
Sum += Sub_Funclet_253();
Sum += Sub_Funclet_254();
Sum += Sub_Funclet_255();
Sum += Sub_Funclet_256();
Sum += Sub_Funclet_257();
Sum += Sub_Funclet_258();
Sum += Sub_Funclet_259();
Sum += Sub_Funclet_260();
Sum += Sub_Funclet_261();
Sum += Sub_Funclet_262();
Sum += Sub_Funclet_263();
Sum += Sub_Funclet_264();
Sum += Sub_Funclet_265();
Sum += Sub_Funclet_266();
Sum += Sub_Funclet_267();
Sum += Sub_Funclet_268();
Sum += Sub_Funclet_269();
Sum += Sub_Funclet_270();
Sum += Sub_Funclet_271();
Sum += Sub_Funclet_272();
Sum += Sub_Funclet_273();
Sum += Sub_Funclet_274();
Sum += Sub_Funclet_275();
Sum += Sub_Funclet_276();
Sum += Sub_Funclet_277();
Sum += Sub_Funclet_278();
Sum += Sub_Funclet_279();
Sum += Sub_Funclet_280();
Sum += Sub_Funclet_281();
Sum += Sub_Funclet_282();
Sum += Sub_Funclet_283();
Sum += Sub_Funclet_284();
Sum += Sub_Funclet_285();
Sum += Sub_Funclet_286();
Sum += Sub_Funclet_287();
Sum += Sub_Funclet_288();
Sum += Sub_Funclet_289();
Sum += Sub_Funclet_290();
Sum += Sub_Funclet_291();
Sum += Sub_Funclet_292();
Sum += Sub_Funclet_293();
Sum += Sub_Funclet_294();
Sum += Sub_Funclet_295();
Sum += Sub_Funclet_296();
Sum += Sub_Funclet_297();
Sum += Sub_Funclet_298();
Sum += Sub_Funclet_299();
Sum += Sub_Funclet_300();
Sum += Sub_Funclet_301();
Sum += Sub_Funclet_302();
Sum += Sub_Funclet_303();
Sum += Sub_Funclet_304();
Sum += Sub_Funclet_305();
Sum += Sub_Funclet_306();
Sum += Sub_Funclet_307();
Sum += Sub_Funclet_308();
Sum += Sub_Funclet_309();
Sum += Sub_Funclet_310();
Sum += Sub_Funclet_311();
Sum += Sub_Funclet_312();
Sum += Sub_Funclet_313();
Sum += Sub_Funclet_314();
Sum += Sub_Funclet_315();
Sum += Sub_Funclet_316();
Sum += Sub_Funclet_317();
Sum += Sub_Funclet_318();
Sum += Sub_Funclet_319();
Sum += Sub_Funclet_320();
Sum += Sub_Funclet_321();
Sum += Sub_Funclet_322();
Sum += Sub_Funclet_323();
Sum += Sub_Funclet_324();
Sum += Sub_Funclet_325();
Sum += Sub_Funclet_326();
Sum += Sub_Funclet_327();
Sum += Sub_Funclet_328();
Sum += Sub_Funclet_329();
Sum += Sub_Funclet_330();
Sum += Sub_Funclet_331();
Sum += Sub_Funclet_332();
Sum += Sub_Funclet_333();
Sum += Sub_Funclet_334();
Sum += Sub_Funclet_335();
Sum += Sub_Funclet_336();
Sum += Sub_Funclet_337();
Sum += Sub_Funclet_338();
Sum += Sub_Funclet_339();
Sum += Sub_Funclet_340();
Sum += Sub_Funclet_341();
Sum += Sub_Funclet_342();
Sum += Sub_Funclet_343();
Sum += Sub_Funclet_344();
Sum += Sub_Funclet_345();
Sum += Sub_Funclet_346();
Sum += Sub_Funclet_347();
Sum += Sub_Funclet_348();
Sum += Sub_Funclet_349();
Sum += Sub_Funclet_350();
Sum += Sub_Funclet_351();
Sum += Sub_Funclet_352();
Sum += Sub_Funclet_353();
Sum += Sub_Funclet_354();
Sum += Sub_Funclet_355();
Sum += Sub_Funclet_356();
Sum += Sub_Funclet_357();
Sum += Sub_Funclet_358();
Sum += Sub_Funclet_359();
Sum += Sub_Funclet_360();
Sum += Sub_Funclet_361();
Sum += Sub_Funclet_362();
Sum += Sub_Funclet_363();
Sum += Sub_Funclet_364();
Sum += Sub_Funclet_365();
Sum += Sub_Funclet_366();
Sum += Sub_Funclet_367();
Sum += Sub_Funclet_368();
Sum += Sub_Funclet_369();
Sum += Sub_Funclet_370();
Sum += Sub_Funclet_371();
Sum += Sub_Funclet_372();
Sum += Sub_Funclet_373();
Sum += Sub_Funclet_374();
Sum += Sub_Funclet_375();
Sum += Sub_Funclet_376();
Sum += Sub_Funclet_377();
Sum += Sub_Funclet_378();
Sum += Sub_Funclet_379();
Sum += Sub_Funclet_380();
Sum += Sub_Funclet_381();
Sum += Sub_Funclet_382();
Sum += Sub_Funclet_383();
Sum += Sub_Funclet_384();
Sum += Sub_Funclet_385();
Sum += Sub_Funclet_386();
Sum += Sub_Funclet_387();
Sum += Sub_Funclet_388();
Sum += Sub_Funclet_389();
Sum += Sub_Funclet_390();
Sum += Sub_Funclet_391();
Sum += Sub_Funclet_392();
Sum += Sub_Funclet_393();
Sum += Sub_Funclet_394();
Sum += Sub_Funclet_395();
Sum += Sub_Funclet_396();
Sum += Sub_Funclet_397();
Sum += Sub_Funclet_398();
Sum += Sub_Funclet_399();
Sum += Sub_Funclet_400();
Sum += Sub_Funclet_401();
Sum += Sub_Funclet_402();
Sum += Sub_Funclet_403();
Sum += Sub_Funclet_404();
Sum += Sub_Funclet_405();
Sum += Sub_Funclet_406();
Sum += Sub_Funclet_407();
Sum += Sub_Funclet_408();
Sum += Sub_Funclet_409();
Sum += Sub_Funclet_410();
Sum += Sub_Funclet_411();
Sum += Sub_Funclet_412();
Sum += Sub_Funclet_413();
Sum += Sub_Funclet_414();
Sum += Sub_Funclet_415();
Sum += Sub_Funclet_416();
Sum += Sub_Funclet_417();
Sum += Sub_Funclet_418();
Sum += Sub_Funclet_419();
Sum += Sub_Funclet_420();
Sum += Sub_Funclet_421();
Sum += Sub_Funclet_422();
Sum += Sub_Funclet_423();
Sum += Sub_Funclet_424();
Sum += Sub_Funclet_425();
Sum += Sub_Funclet_426();
Sum += Sub_Funclet_427();
Sum += Sub_Funclet_428();
Sum += Sub_Funclet_429();
Sum += Sub_Funclet_430();
Sum += Sub_Funclet_431();
Sum += Sub_Funclet_432();
Sum += Sub_Funclet_433();
Sum += Sub_Funclet_434();
Sum += Sub_Funclet_435();
Sum += Sub_Funclet_436();
Sum += Sub_Funclet_437();
Sum += Sub_Funclet_438();
Sum += Sub_Funclet_439();
Sum += Sub_Funclet_440();
Sum += Sub_Funclet_441();
Sum += Sub_Funclet_442();
Sum += Sub_Funclet_443();
Sum += Sub_Funclet_444();
Sum += Sub_Funclet_445();
Sum += Sub_Funclet_446();
Sum += Sub_Funclet_447();
Sum += Sub_Funclet_448();
Sum += Sub_Funclet_449();
Sum += Sub_Funclet_450();
Sum += Sub_Funclet_451();
Sum += Sub_Funclet_452();
Sum += Sub_Funclet_453();
Sum += Sub_Funclet_454();
Sum += Sub_Funclet_455();
Sum += Sub_Funclet_456();
Sum += Sub_Funclet_457();
Sum += Sub_Funclet_458();
Sum += Sub_Funclet_459();
Sum += Sub_Funclet_460();
if (Sum == 11520)
{
Console.WriteLine("PASSED");
return 100;
}
else
{
Console.WriteLine("FAILED");
return 1;
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
#pragma warning disable
using System;
class testout1
{
static bool static_field_bool;
static bool sfb_false;
static bool sfb_true;
bool mfb;
bool mfb_false;
bool mfb_true;
static bool simple_func_bool()
{
return true;
}
static bool func_sb_true()
{
return true;
}
static bool func_sb_false()
{
return false;
}
static int Sub_Funclet_0()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && true ? true : true) True_Sum++; else False_Sum++;
if (true && true ? true : false) True_Sum++; else False_Sum++;
if (true && true ? true : local_bool) True_Sum++; else False_Sum++;
if (true && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? false : true) True_Sum++; else False_Sum++;
if (true && true ? false : false) True_Sum++; else False_Sum++;
if (true && true ? false : local_bool) True_Sum++; else False_Sum++;
if (true && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? local_bool : true) True_Sum++; else False_Sum++;
if (true && true ? local_bool : false) True_Sum++; else False_Sum++;
if (true && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_1()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_2()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_3()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? true : true) True_Sum++; else False_Sum++;
if (true && false ? true : false) True_Sum++; else False_Sum++;
if (true && false ? true : local_bool) True_Sum++; else False_Sum++;
if (true && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? false : true) True_Sum++; else False_Sum++;
if (true && false ? false : false) True_Sum++; else False_Sum++;
if (true && false ? false : local_bool) True_Sum++; else False_Sum++;
if (true && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_4()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && false ? local_bool : true) True_Sum++; else False_Sum++;
if (true && false ? local_bool : false) True_Sum++; else False_Sum++;
if (true && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_5()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_6()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? true : true) True_Sum++; else False_Sum++;
if (true && lb_true ? true : false) True_Sum++; else False_Sum++;
if (true && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? false : true) True_Sum++; else False_Sum++;
if (true && lb_true ? false : false) True_Sum++; else False_Sum++;
if (true && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_7()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_8()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_9()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? true : true) True_Sum++; else False_Sum++;
if (true && lb_false ? true : false) True_Sum++; else False_Sum++;
if (true && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_10()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_false ? false : true) True_Sum++; else False_Sum++;
if (true && lb_false ? false : false) True_Sum++; else False_Sum++;
if (true && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_11()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_12()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_13()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_14()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_15()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_16()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_17()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_18()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_19()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_20()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_21()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_22()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_23()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_24()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_25()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_26()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_27()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_28()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_29()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_30()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_31()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_32()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_33()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_34()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_35()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_36()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_37()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_38()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (true && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (true && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? true : true) True_Sum++; else False_Sum++;
if (false && true ? true : false) True_Sum++; else False_Sum++;
if (false && true ? true : local_bool) True_Sum++; else False_Sum++;
if (false && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? false : true) True_Sum++; else False_Sum++;
if (false && true ? false : false) True_Sum++; else False_Sum++;
if (false && true ? false : local_bool) True_Sum++; else False_Sum++;
if (false && true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_39()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? local_bool : true) True_Sum++; else False_Sum++;
if (false && true ? local_bool : false) True_Sum++; else False_Sum++;
if (false && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_40()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_41()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? true : true) True_Sum++; else False_Sum++;
if (false && false ? true : false) True_Sum++; else False_Sum++;
if (false && false ? true : local_bool) True_Sum++; else False_Sum++;
if (false && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_42()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && false ? false : true) True_Sum++; else False_Sum++;
if (false && false ? false : false) True_Sum++; else False_Sum++;
if (false && false ? false : local_bool) True_Sum++; else False_Sum++;
if (false && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? local_bool : true) True_Sum++; else False_Sum++;
if (false && false ? local_bool : false) True_Sum++; else False_Sum++;
if (false && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_43()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_44()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? true : true) True_Sum++; else False_Sum++;
if (false && lb_true ? true : false) True_Sum++; else False_Sum++;
if (false && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_45()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? false : true) True_Sum++; else False_Sum++;
if (false && lb_true ? false : false) True_Sum++; else False_Sum++;
if (false && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_46()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_47()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_48()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_false ? true : true) True_Sum++; else False_Sum++;
if (false && lb_false ? true : false) True_Sum++; else False_Sum++;
if (false && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? false : true) True_Sum++; else False_Sum++;
if (false && lb_false ? false : false) True_Sum++; else False_Sum++;
if (false && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_49()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_50()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_51()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_52()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_53()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_54()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_55()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_56()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_57()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_58()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_59()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_60()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_61()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_62()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_63()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_64()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_65()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_66()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_67()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_68()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_69()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_70()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_71()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_72()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_73()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_74()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_75()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_76()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (false && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (false && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? true : true) True_Sum++; else False_Sum++;
if (lb_true && true ? true : false) True_Sum++; else False_Sum++;
if (lb_true && true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_77()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? false : true) True_Sum++; else False_Sum++;
if (lb_true && true ? false : false) True_Sum++; else False_Sum++;
if (lb_true && true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_78()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_79()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_80()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && false ? true : true) True_Sum++; else False_Sum++;
if (lb_true && false ? true : false) True_Sum++; else False_Sum++;
if (lb_true && false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? false : true) True_Sum++; else False_Sum++;
if (lb_true && false ? false : false) True_Sum++; else False_Sum++;
if (lb_true && false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_81()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_82()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_83()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_84()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_85()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_86()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_87()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_88()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_89()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_90()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_91()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_92()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_93()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_94()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_95()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_96()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_97()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_98()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_99()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_100()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_101()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_102()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_103()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_104()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_105()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_106()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_107()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_108()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_109()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_110()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_111()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_112()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_113()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_114()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_115()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_true && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_true && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? true : true) True_Sum++; else False_Sum++;
if (lb_false && true ? true : false) True_Sum++; else False_Sum++;
if (lb_false && true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? false : true) True_Sum++; else False_Sum++;
if (lb_false && true ? false : false) True_Sum++; else False_Sum++;
if (lb_false && true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_116()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_117()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_118()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? true : true) True_Sum++; else False_Sum++;
if (lb_false && false ? true : false) True_Sum++; else False_Sum++;
if (lb_false && false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? false : true) True_Sum++; else False_Sum++;
if (lb_false && false ? false : false) True_Sum++; else False_Sum++;
if (lb_false && false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_119()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_120()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_121()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_122()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_123()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_124()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_125()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_126()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_127()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_128()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_129()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_130()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_131()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_132()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_133()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_134()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_135()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_136()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_137()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_138()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_139()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_140()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_141()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_142()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_143()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_144()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_145()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_146()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_147()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_148()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_149()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_150()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_151()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_152()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_153()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (lb_false && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (lb_false && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_154()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && true ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_155()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_156()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_157()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_158()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_159()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_160()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_161()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_162()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_163()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_164()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_165()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_166()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_167()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_168()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_169()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_170()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_171()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_172()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_173()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_174()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_175()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_176()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_177()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_178()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_179()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_180()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_181()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_182()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_183()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_184()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_185()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_186()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_187()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_188()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_189()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_190()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_191()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_true && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_true && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_192()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && true ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_193()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_194()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_195()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_196()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_197()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_198()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_199()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_200()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_201()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_202()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_203()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_204()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_205()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_206()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_207()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_208()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_209()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_210()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_211()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_212()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_213()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_214()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_215()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_216()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_217()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_218()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_219()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_220()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_221()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_222()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_223()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_224()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_225()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_226()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_227()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_228()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_229()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_230()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (sfb_false && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (sfb_false && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_231()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_232()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_233()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_234()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_235()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_236()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_237()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_238()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_239()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_240()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_241()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_242()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_243()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_244()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_245()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_246()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_247()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_248()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_249()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_250()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_251()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_252()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_253()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_254()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_255()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_256()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_257()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_258()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_259()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_260()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_261()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_262()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_263()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_264()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_265()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_266()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_267()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_268()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_true && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_269()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_270()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_271()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_272()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_273()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_274()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_275()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_276()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_277()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_278()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_279()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_280()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_281()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_282()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_283()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_284()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_285()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_286()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_287()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_288()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_289()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_290()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_291()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_292()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_293()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_294()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_295()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_296()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_297()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_298()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_299()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_300()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_301()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_302()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_303()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_304()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_305()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_306()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_307()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (t1_i.mfb_false && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_308()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_309()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_310()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_311()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_312()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_313()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_314()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_315()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_316()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_317()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_318()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_319()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_320()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_321()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_322()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_323()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_324()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_325()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_326()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_327()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_328()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_329()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_330()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_331()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_332()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_333()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_334()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_335()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_336()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_337()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_338()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_339()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_340()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_341()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_342()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_343()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_344()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_345()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_true() && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_true() && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_346()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_347()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_348()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_349()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_350()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_351()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_352()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_353()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_354()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_355()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_356()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_357()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_358()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_359()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_360()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_361()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_362()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_363()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_364()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_365()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_366()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_367()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_368()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_369()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_370()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_371()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_372()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_373()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_374()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_375()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_376()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_377()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_378()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_379()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_380()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_381()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_382()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_383()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (func_sb_false() && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_384()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && true ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_385()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_386()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_387()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_388()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_389()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_390()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_391()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_392()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_393()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_394()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_395()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_396()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_397()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_398()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_399()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_400()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_401()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_402()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_403()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_404()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_405()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_406()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_407()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_408()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_409()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_410()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_411()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_412()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_413()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_414()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_415()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_416()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_417()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_418()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_419()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_420()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_421()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_422()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_true[index] && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_true[index] && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_423()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_424()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_425()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_426()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && false ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_427()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_428()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_429()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_430()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_431()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_432()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_433()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_434()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_435()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && lb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && lb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_436()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_437()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_438()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_439()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_440()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_441()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && sfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && sfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_442()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_true ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_443()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_444()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_true ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_445()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_false ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_446()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_447()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && t1_i.mfb_false ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_448()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_true() ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_449()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_true() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_450()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_451()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_true() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_true() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? false : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_452()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_false() ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_453()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_454()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && func_sb_false() ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && func_sb_false() ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_455()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_true[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_456()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_457()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_true[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_true[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? true : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_458()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_false[index] ? false : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? false : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? local_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : static_field_bool) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_459()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_false[index] ? static_field_bool : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? static_field_bool : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? t1_i.mfb : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? simple_func_bool() : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
static int Sub_Funclet_460()
{
int True_Sum = 0;
int False_Sum = 0;
int index = 1;
bool local_bool = true;
bool lb_false = false;
bool lb_true = true;
testout1 t1_i = new testout1();
bool[] ab_false = new bool[3];
bool[] ab_true = new bool[3];
ab_true[0] = true;
ab_true[1] = true;
ab_true[2] = true;
static_field_bool = true;
sfb_false = false;
sfb_true = true;
t1_i.mfb = true;
t1_i.mfb_false = false;
t1_i.mfb_true = true;
if (ab_false[index] && ab_false[index] ? ab_true[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_true[index] : ab_false[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : true) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : false) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : local_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : static_field_bool) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : t1_i.mfb) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : simple_func_bool()) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : ab_true[index]) True_Sum++; else False_Sum++;
if (ab_false[index] && ab_false[index] ? ab_false[index] : ab_false[index]) True_Sum++; else False_Sum++;
return (True_Sum * 2) - False_Sum;
}
public static int Main()
{
int Sum = 0;
Sum += Sub_Funclet_0();
Sum += Sub_Funclet_1();
Sum += Sub_Funclet_2();
Sum += Sub_Funclet_3();
Sum += Sub_Funclet_4();
Sum += Sub_Funclet_5();
Sum += Sub_Funclet_6();
Sum += Sub_Funclet_7();
Sum += Sub_Funclet_8();
Sum += Sub_Funclet_9();
Sum += Sub_Funclet_10();
Sum += Sub_Funclet_11();
Sum += Sub_Funclet_12();
Sum += Sub_Funclet_13();
Sum += Sub_Funclet_14();
Sum += Sub_Funclet_15();
Sum += Sub_Funclet_16();
Sum += Sub_Funclet_17();
Sum += Sub_Funclet_18();
Sum += Sub_Funclet_19();
Sum += Sub_Funclet_20();
Sum += Sub_Funclet_21();
Sum += Sub_Funclet_22();
Sum += Sub_Funclet_23();
Sum += Sub_Funclet_24();
Sum += Sub_Funclet_25();
Sum += Sub_Funclet_26();
Sum += Sub_Funclet_27();
Sum += Sub_Funclet_28();
Sum += Sub_Funclet_29();
Sum += Sub_Funclet_30();
Sum += Sub_Funclet_31();
Sum += Sub_Funclet_32();
Sum += Sub_Funclet_33();
Sum += Sub_Funclet_34();
Sum += Sub_Funclet_35();
Sum += Sub_Funclet_36();
Sum += Sub_Funclet_37();
Sum += Sub_Funclet_38();
Sum += Sub_Funclet_39();
Sum += Sub_Funclet_40();
Sum += Sub_Funclet_41();
Sum += Sub_Funclet_42();
Sum += Sub_Funclet_43();
Sum += Sub_Funclet_44();
Sum += Sub_Funclet_45();
Sum += Sub_Funclet_46();
Sum += Sub_Funclet_47();
Sum += Sub_Funclet_48();
Sum += Sub_Funclet_49();
Sum += Sub_Funclet_50();
Sum += Sub_Funclet_51();
Sum += Sub_Funclet_52();
Sum += Sub_Funclet_53();
Sum += Sub_Funclet_54();
Sum += Sub_Funclet_55();
Sum += Sub_Funclet_56();
Sum += Sub_Funclet_57();
Sum += Sub_Funclet_58();
Sum += Sub_Funclet_59();
Sum += Sub_Funclet_60();
Sum += Sub_Funclet_61();
Sum += Sub_Funclet_62();
Sum += Sub_Funclet_63();
Sum += Sub_Funclet_64();
Sum += Sub_Funclet_65();
Sum += Sub_Funclet_66();
Sum += Sub_Funclet_67();
Sum += Sub_Funclet_68();
Sum += Sub_Funclet_69();
Sum += Sub_Funclet_70();
Sum += Sub_Funclet_71();
Sum += Sub_Funclet_72();
Sum += Sub_Funclet_73();
Sum += Sub_Funclet_74();
Sum += Sub_Funclet_75();
Sum += Sub_Funclet_76();
Sum += Sub_Funclet_77();
Sum += Sub_Funclet_78();
Sum += Sub_Funclet_79();
Sum += Sub_Funclet_80();
Sum += Sub_Funclet_81();
Sum += Sub_Funclet_82();
Sum += Sub_Funclet_83();
Sum += Sub_Funclet_84();
Sum += Sub_Funclet_85();
Sum += Sub_Funclet_86();
Sum += Sub_Funclet_87();
Sum += Sub_Funclet_88();
Sum += Sub_Funclet_89();
Sum += Sub_Funclet_90();
Sum += Sub_Funclet_91();
Sum += Sub_Funclet_92();
Sum += Sub_Funclet_93();
Sum += Sub_Funclet_94();
Sum += Sub_Funclet_95();
Sum += Sub_Funclet_96();
Sum += Sub_Funclet_97();
Sum += Sub_Funclet_98();
Sum += Sub_Funclet_99();
Sum += Sub_Funclet_100();
Sum += Sub_Funclet_101();
Sum += Sub_Funclet_102();
Sum += Sub_Funclet_103();
Sum += Sub_Funclet_104();
Sum += Sub_Funclet_105();
Sum += Sub_Funclet_106();
Sum += Sub_Funclet_107();
Sum += Sub_Funclet_108();
Sum += Sub_Funclet_109();
Sum += Sub_Funclet_110();
Sum += Sub_Funclet_111();
Sum += Sub_Funclet_112();
Sum += Sub_Funclet_113();
Sum += Sub_Funclet_114();
Sum += Sub_Funclet_115();
Sum += Sub_Funclet_116();
Sum += Sub_Funclet_117();
Sum += Sub_Funclet_118();
Sum += Sub_Funclet_119();
Sum += Sub_Funclet_120();
Sum += Sub_Funclet_121();
Sum += Sub_Funclet_122();
Sum += Sub_Funclet_123();
Sum += Sub_Funclet_124();
Sum += Sub_Funclet_125();
Sum += Sub_Funclet_126();
Sum += Sub_Funclet_127();
Sum += Sub_Funclet_128();
Sum += Sub_Funclet_129();
Sum += Sub_Funclet_130();
Sum += Sub_Funclet_131();
Sum += Sub_Funclet_132();
Sum += Sub_Funclet_133();
Sum += Sub_Funclet_134();
Sum += Sub_Funclet_135();
Sum += Sub_Funclet_136();
Sum += Sub_Funclet_137();
Sum += Sub_Funclet_138();
Sum += Sub_Funclet_139();
Sum += Sub_Funclet_140();
Sum += Sub_Funclet_141();
Sum += Sub_Funclet_142();
Sum += Sub_Funclet_143();
Sum += Sub_Funclet_144();
Sum += Sub_Funclet_145();
Sum += Sub_Funclet_146();
Sum += Sub_Funclet_147();
Sum += Sub_Funclet_148();
Sum += Sub_Funclet_149();
Sum += Sub_Funclet_150();
Sum += Sub_Funclet_151();
Sum += Sub_Funclet_152();
Sum += Sub_Funclet_153();
Sum += Sub_Funclet_154();
Sum += Sub_Funclet_155();
Sum += Sub_Funclet_156();
Sum += Sub_Funclet_157();
Sum += Sub_Funclet_158();
Sum += Sub_Funclet_159();
Sum += Sub_Funclet_160();
Sum += Sub_Funclet_161();
Sum += Sub_Funclet_162();
Sum += Sub_Funclet_163();
Sum += Sub_Funclet_164();
Sum += Sub_Funclet_165();
Sum += Sub_Funclet_166();
Sum += Sub_Funclet_167();
Sum += Sub_Funclet_168();
Sum += Sub_Funclet_169();
Sum += Sub_Funclet_170();
Sum += Sub_Funclet_171();
Sum += Sub_Funclet_172();
Sum += Sub_Funclet_173();
Sum += Sub_Funclet_174();
Sum += Sub_Funclet_175();
Sum += Sub_Funclet_176();
Sum += Sub_Funclet_177();
Sum += Sub_Funclet_178();
Sum += Sub_Funclet_179();
Sum += Sub_Funclet_180();
Sum += Sub_Funclet_181();
Sum += Sub_Funclet_182();
Sum += Sub_Funclet_183();
Sum += Sub_Funclet_184();
Sum += Sub_Funclet_185();
Sum += Sub_Funclet_186();
Sum += Sub_Funclet_187();
Sum += Sub_Funclet_188();
Sum += Sub_Funclet_189();
Sum += Sub_Funclet_190();
Sum += Sub_Funclet_191();
Sum += Sub_Funclet_192();
Sum += Sub_Funclet_193();
Sum += Sub_Funclet_194();
Sum += Sub_Funclet_195();
Sum += Sub_Funclet_196();
Sum += Sub_Funclet_197();
Sum += Sub_Funclet_198();
Sum += Sub_Funclet_199();
Sum += Sub_Funclet_200();
Sum += Sub_Funclet_201();
Sum += Sub_Funclet_202();
Sum += Sub_Funclet_203();
Sum += Sub_Funclet_204();
Sum += Sub_Funclet_205();
Sum += Sub_Funclet_206();
Sum += Sub_Funclet_207();
Sum += Sub_Funclet_208();
Sum += Sub_Funclet_209();
Sum += Sub_Funclet_210();
Sum += Sub_Funclet_211();
Sum += Sub_Funclet_212();
Sum += Sub_Funclet_213();
Sum += Sub_Funclet_214();
Sum += Sub_Funclet_215();
Sum += Sub_Funclet_216();
Sum += Sub_Funclet_217();
Sum += Sub_Funclet_218();
Sum += Sub_Funclet_219();
Sum += Sub_Funclet_220();
Sum += Sub_Funclet_221();
Sum += Sub_Funclet_222();
Sum += Sub_Funclet_223();
Sum += Sub_Funclet_224();
Sum += Sub_Funclet_225();
Sum += Sub_Funclet_226();
Sum += Sub_Funclet_227();
Sum += Sub_Funclet_228();
Sum += Sub_Funclet_229();
Sum += Sub_Funclet_230();
Sum += Sub_Funclet_231();
Sum += Sub_Funclet_232();
Sum += Sub_Funclet_233();
Sum += Sub_Funclet_234();
Sum += Sub_Funclet_235();
Sum += Sub_Funclet_236();
Sum += Sub_Funclet_237();
Sum += Sub_Funclet_238();
Sum += Sub_Funclet_239();
Sum += Sub_Funclet_240();
Sum += Sub_Funclet_241();
Sum += Sub_Funclet_242();
Sum += Sub_Funclet_243();
Sum += Sub_Funclet_244();
Sum += Sub_Funclet_245();
Sum += Sub_Funclet_246();
Sum += Sub_Funclet_247();
Sum += Sub_Funclet_248();
Sum += Sub_Funclet_249();
Sum += Sub_Funclet_250();
Sum += Sub_Funclet_251();
Sum += Sub_Funclet_252();
Sum += Sub_Funclet_253();
Sum += Sub_Funclet_254();
Sum += Sub_Funclet_255();
Sum += Sub_Funclet_256();
Sum += Sub_Funclet_257();
Sum += Sub_Funclet_258();
Sum += Sub_Funclet_259();
Sum += Sub_Funclet_260();
Sum += Sub_Funclet_261();
Sum += Sub_Funclet_262();
Sum += Sub_Funclet_263();
Sum += Sub_Funclet_264();
Sum += Sub_Funclet_265();
Sum += Sub_Funclet_266();
Sum += Sub_Funclet_267();
Sum += Sub_Funclet_268();
Sum += Sub_Funclet_269();
Sum += Sub_Funclet_270();
Sum += Sub_Funclet_271();
Sum += Sub_Funclet_272();
Sum += Sub_Funclet_273();
Sum += Sub_Funclet_274();
Sum += Sub_Funclet_275();
Sum += Sub_Funclet_276();
Sum += Sub_Funclet_277();
Sum += Sub_Funclet_278();
Sum += Sub_Funclet_279();
Sum += Sub_Funclet_280();
Sum += Sub_Funclet_281();
Sum += Sub_Funclet_282();
Sum += Sub_Funclet_283();
Sum += Sub_Funclet_284();
Sum += Sub_Funclet_285();
Sum += Sub_Funclet_286();
Sum += Sub_Funclet_287();
Sum += Sub_Funclet_288();
Sum += Sub_Funclet_289();
Sum += Sub_Funclet_290();
Sum += Sub_Funclet_291();
Sum += Sub_Funclet_292();
Sum += Sub_Funclet_293();
Sum += Sub_Funclet_294();
Sum += Sub_Funclet_295();
Sum += Sub_Funclet_296();
Sum += Sub_Funclet_297();
Sum += Sub_Funclet_298();
Sum += Sub_Funclet_299();
Sum += Sub_Funclet_300();
Sum += Sub_Funclet_301();
Sum += Sub_Funclet_302();
Sum += Sub_Funclet_303();
Sum += Sub_Funclet_304();
Sum += Sub_Funclet_305();
Sum += Sub_Funclet_306();
Sum += Sub_Funclet_307();
Sum += Sub_Funclet_308();
Sum += Sub_Funclet_309();
Sum += Sub_Funclet_310();
Sum += Sub_Funclet_311();
Sum += Sub_Funclet_312();
Sum += Sub_Funclet_313();
Sum += Sub_Funclet_314();
Sum += Sub_Funclet_315();
Sum += Sub_Funclet_316();
Sum += Sub_Funclet_317();
Sum += Sub_Funclet_318();
Sum += Sub_Funclet_319();
Sum += Sub_Funclet_320();
Sum += Sub_Funclet_321();
Sum += Sub_Funclet_322();
Sum += Sub_Funclet_323();
Sum += Sub_Funclet_324();
Sum += Sub_Funclet_325();
Sum += Sub_Funclet_326();
Sum += Sub_Funclet_327();
Sum += Sub_Funclet_328();
Sum += Sub_Funclet_329();
Sum += Sub_Funclet_330();
Sum += Sub_Funclet_331();
Sum += Sub_Funclet_332();
Sum += Sub_Funclet_333();
Sum += Sub_Funclet_334();
Sum += Sub_Funclet_335();
Sum += Sub_Funclet_336();
Sum += Sub_Funclet_337();
Sum += Sub_Funclet_338();
Sum += Sub_Funclet_339();
Sum += Sub_Funclet_340();
Sum += Sub_Funclet_341();
Sum += Sub_Funclet_342();
Sum += Sub_Funclet_343();
Sum += Sub_Funclet_344();
Sum += Sub_Funclet_345();
Sum += Sub_Funclet_346();
Sum += Sub_Funclet_347();
Sum += Sub_Funclet_348();
Sum += Sub_Funclet_349();
Sum += Sub_Funclet_350();
Sum += Sub_Funclet_351();
Sum += Sub_Funclet_352();
Sum += Sub_Funclet_353();
Sum += Sub_Funclet_354();
Sum += Sub_Funclet_355();
Sum += Sub_Funclet_356();
Sum += Sub_Funclet_357();
Sum += Sub_Funclet_358();
Sum += Sub_Funclet_359();
Sum += Sub_Funclet_360();
Sum += Sub_Funclet_361();
Sum += Sub_Funclet_362();
Sum += Sub_Funclet_363();
Sum += Sub_Funclet_364();
Sum += Sub_Funclet_365();
Sum += Sub_Funclet_366();
Sum += Sub_Funclet_367();
Sum += Sub_Funclet_368();
Sum += Sub_Funclet_369();
Sum += Sub_Funclet_370();
Sum += Sub_Funclet_371();
Sum += Sub_Funclet_372();
Sum += Sub_Funclet_373();
Sum += Sub_Funclet_374();
Sum += Sub_Funclet_375();
Sum += Sub_Funclet_376();
Sum += Sub_Funclet_377();
Sum += Sub_Funclet_378();
Sum += Sub_Funclet_379();
Sum += Sub_Funclet_380();
Sum += Sub_Funclet_381();
Sum += Sub_Funclet_382();
Sum += Sub_Funclet_383();
Sum += Sub_Funclet_384();
Sum += Sub_Funclet_385();
Sum += Sub_Funclet_386();
Sum += Sub_Funclet_387();
Sum += Sub_Funclet_388();
Sum += Sub_Funclet_389();
Sum += Sub_Funclet_390();
Sum += Sub_Funclet_391();
Sum += Sub_Funclet_392();
Sum += Sub_Funclet_393();
Sum += Sub_Funclet_394();
Sum += Sub_Funclet_395();
Sum += Sub_Funclet_396();
Sum += Sub_Funclet_397();
Sum += Sub_Funclet_398();
Sum += Sub_Funclet_399();
Sum += Sub_Funclet_400();
Sum += Sub_Funclet_401();
Sum += Sub_Funclet_402();
Sum += Sub_Funclet_403();
Sum += Sub_Funclet_404();
Sum += Sub_Funclet_405();
Sum += Sub_Funclet_406();
Sum += Sub_Funclet_407();
Sum += Sub_Funclet_408();
Sum += Sub_Funclet_409();
Sum += Sub_Funclet_410();
Sum += Sub_Funclet_411();
Sum += Sub_Funclet_412();
Sum += Sub_Funclet_413();
Sum += Sub_Funclet_414();
Sum += Sub_Funclet_415();
Sum += Sub_Funclet_416();
Sum += Sub_Funclet_417();
Sum += Sub_Funclet_418();
Sum += Sub_Funclet_419();
Sum += Sub_Funclet_420();
Sum += Sub_Funclet_421();
Sum += Sub_Funclet_422();
Sum += Sub_Funclet_423();
Sum += Sub_Funclet_424();
Sum += Sub_Funclet_425();
Sum += Sub_Funclet_426();
Sum += Sub_Funclet_427();
Sum += Sub_Funclet_428();
Sum += Sub_Funclet_429();
Sum += Sub_Funclet_430();
Sum += Sub_Funclet_431();
Sum += Sub_Funclet_432();
Sum += Sub_Funclet_433();
Sum += Sub_Funclet_434();
Sum += Sub_Funclet_435();
Sum += Sub_Funclet_436();
Sum += Sub_Funclet_437();
Sum += Sub_Funclet_438();
Sum += Sub_Funclet_439();
Sum += Sub_Funclet_440();
Sum += Sub_Funclet_441();
Sum += Sub_Funclet_442();
Sum += Sub_Funclet_443();
Sum += Sub_Funclet_444();
Sum += Sub_Funclet_445();
Sum += Sub_Funclet_446();
Sum += Sub_Funclet_447();
Sum += Sub_Funclet_448();
Sum += Sub_Funclet_449();
Sum += Sub_Funclet_450();
Sum += Sub_Funclet_451();
Sum += Sub_Funclet_452();
Sum += Sub_Funclet_453();
Sum += Sub_Funclet_454();
Sum += Sub_Funclet_455();
Sum += Sub_Funclet_456();
Sum += Sub_Funclet_457();
Sum += Sub_Funclet_458();
Sum += Sub_Funclet_459();
Sum += Sub_Funclet_460();
if (Sum == 11520)
{
Console.WriteLine("PASSED");
return 100;
}
else
{
Console.WriteLine("FAILED");
return 1;
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/DelegateHelpers.Generated.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics;
using System.Dynamic.Utils;
namespace System.Linq.Expressions.Compiler
{
internal static partial class DelegateHelpers
{
/// <summary>
/// Finds a delegate type using the types in the array.
/// We use the cache to avoid copying the array, and to cache the
/// created delegate type
/// </summary>
internal static Type MakeDelegateType(Type[] types)
{
lock (_DelegateCache)
{
TypeInfo curTypeInfo = _DelegateCache;
// arguments & return type
for (int i = 0; i < types.Length; i++)
{
curTypeInfo = NextTypeInfo(types[i], curTypeInfo);
}
// see if we have the delegate already
if (curTypeInfo.DelegateType == null)
{
// clone because MakeCustomDelegate can hold onto the array.
curTypeInfo.DelegateType = MakeNewDelegate((Type[])types.Clone());
}
return curTypeInfo.DelegateType;
}
}
internal static TypeInfo NextTypeInfo(Type initialArg)
{
lock (_DelegateCache)
{
return NextTypeInfo(initialArg, _DelegateCache);
}
}
internal static TypeInfo GetNextTypeInfo(Type initialArg, TypeInfo curTypeInfo)
{
lock (_DelegateCache)
{
return NextTypeInfo(initialArg, curTypeInfo);
}
}
private static TypeInfo _DelegateCache = new TypeInfo();
private const int MaximumArity = 17;
internal sealed class TypeInfo
{
public Type DelegateType;
public Dictionary<Type, TypeInfo> TypeChain;
}
private static TypeInfo NextTypeInfo(Type initialArg, TypeInfo curTypeInfo)
{
Type lookingUp = initialArg;
TypeInfo nextTypeInfo;
if (curTypeInfo.TypeChain == null)
{
curTypeInfo.TypeChain = new Dictionary<Type, TypeInfo>();
}
if (!curTypeInfo.TypeChain.TryGetValue(lookingUp, out nextTypeInfo))
{
nextTypeInfo = new TypeInfo();
if (!lookingUp.IsCollectible)
{
curTypeInfo.TypeChain[lookingUp] = nextTypeInfo;
}
}
return nextTypeInfo;
}
public delegate object VBCallSiteDelegate0<T>(T callSite, object instance);
public delegate object VBCallSiteDelegate1<T>(T callSite, object instance, ref object arg1);
public delegate object VBCallSiteDelegate2<T>(T callSite, object instance, ref object arg1, ref object arg2);
public delegate object VBCallSiteDelegate3<T>(T callSite, object instance, ref object arg1, ref object arg2, ref object arg3);
public delegate object VBCallSiteDelegate4<T>(T callSite, object instance, ref object arg1, ref object arg2, ref object arg3, ref object arg4);
public delegate object VBCallSiteDelegate5<T>(T callSite, object instance, ref object arg1, ref object arg2, ref object arg3, ref object arg4, ref object arg5);
public delegate object VBCallSiteDelegate6<T>(T callSite, object instance, ref object arg1, ref object arg2, ref object arg3, ref object arg4, ref object arg5, ref object arg6);
public delegate object VBCallSiteDelegate7<T>(T callSite, object instance, ref object arg1, ref object arg2, ref object arg3, ref object arg4, ref object arg5, ref object arg6, ref object arg7);
private static Type TryMakeVBStyledCallSite(Type[] types)
{
// Shape of VB CallSiteDelegates is CallSite * (instance : obj) * [arg-n : byref obj] -> obj
// array of arguments should contain at least 3 elements (callsite, instance and return type)
if (types.Length < 3 || types[0].IsByRef || types[1] != typeof(object) || types[types.Length - 1] != typeof(object))
{
return null;
}
// check if all arguments starting from the second has type byref<obj>
for (int i = 2; i < types.Length - 2; ++i)
{
Type t = types[i];
if (!t.IsByRef || t.GetElementType() != typeof(object))
{
return null;
}
}
switch (types.Length - 1)
{
case 2: return typeof(VBCallSiteDelegate0<>).MakeGenericType(types[0]);
case 3: return typeof(VBCallSiteDelegate1<>).MakeGenericType(types[0]);
case 4: return typeof(VBCallSiteDelegate2<>).MakeGenericType(types[0]);
case 5: return typeof(VBCallSiteDelegate3<>).MakeGenericType(types[0]);
case 6: return typeof(VBCallSiteDelegate4<>).MakeGenericType(types[0]);
case 7: return typeof(VBCallSiteDelegate5<>).MakeGenericType(types[0]);
case 8: return typeof(VBCallSiteDelegate6<>).MakeGenericType(types[0]);
case 9: return typeof(VBCallSiteDelegate7<>).MakeGenericType(types[0]);
default: return null;
}
}
/// <summary>
/// Creates a new delegate, or uses a func/action
/// Note: this method does not cache
/// </summary>
internal static Type MakeNewDelegate(Type[] types)
{
Debug.Assert(types != null && types.Length > 0);
// Can only used predefined delegates if we have no byref types and
// the arity is small enough to fit in Func<...> or Action<...>
bool needCustom;
if (types.Length > MaximumArity)
{
needCustom = true;
}
else
{
needCustom = false;
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (type.IsByRef || type.IsByRefLike || type.IsPointer)
{
needCustom = true;
break;
}
}
}
if (needCustom)
{
if (LambdaExpression.CanCompileToIL)
{
return MakeNewCustomDelegate(types);
}
else
{
return TryMakeVBStyledCallSite(types) ?? MakeNewCustomDelegate(types);
}
}
Type result;
if (types[types.Length - 1] == typeof(void))
{
result = GetActionType(types.RemoveLast());
}
else
{
result = GetFuncType(types);
}
Debug.Assert(result != null);
return result;
}
internal static Type GetFuncType(Type[] types)
{
switch (types.Length)
{
case 1:
return typeof(Func<>).MakeGenericType(types);
case 2:
return typeof(Func<,>).MakeGenericType(types);
case 3:
return typeof(Func<,,>).MakeGenericType(types);
case 4:
return typeof(Func<,,,>).MakeGenericType(types);
case 5:
return typeof(Func<,,,,>).MakeGenericType(types);
case 6:
return typeof(Func<,,,,,>).MakeGenericType(types);
case 7:
return typeof(Func<,,,,,,>).MakeGenericType(types);
case 8:
return typeof(Func<,,,,,,,>).MakeGenericType(types);
case 9:
return typeof(Func<,,,,,,,,>).MakeGenericType(types);
case 10:
return typeof(Func<,,,,,,,,,>).MakeGenericType(types);
case 11:
return typeof(Func<,,,,,,,,,,>).MakeGenericType(types);
case 12:
return typeof(Func<,,,,,,,,,,,>).MakeGenericType(types);
case 13:
return typeof(Func<,,,,,,,,,,,,>).MakeGenericType(types);
case 14:
return typeof(Func<,,,,,,,,,,,,,>).MakeGenericType(types);
case 15:
return typeof(Func<,,,,,,,,,,,,,,>).MakeGenericType(types);
case 16:
return typeof(Func<,,,,,,,,,,,,,,,>).MakeGenericType(types);
case 17:
return typeof(Func<,,,,,,,,,,,,,,,,>).MakeGenericType(types);
default:
return null;
}
}
internal static Type GetActionType(Type[] types)
{
switch (types.Length)
{
case 0:
return typeof(Action);
case 1:
return typeof(Action<>).MakeGenericType(types);
case 2:
return typeof(Action<,>).MakeGenericType(types);
case 3:
return typeof(Action<,,>).MakeGenericType(types);
case 4:
return typeof(Action<,,,>).MakeGenericType(types);
case 5:
return typeof(Action<,,,,>).MakeGenericType(types);
case 6:
return typeof(Action<,,,,,>).MakeGenericType(types);
case 7:
return typeof(Action<,,,,,,>).MakeGenericType(types);
case 8:
return typeof(Action<,,,,,,,>).MakeGenericType(types);
case 9:
return typeof(Action<,,,,,,,,>).MakeGenericType(types);
case 10:
return typeof(Action<,,,,,,,,,>).MakeGenericType(types);
case 11:
return typeof(Action<,,,,,,,,,,>).MakeGenericType(types);
case 12:
return typeof(Action<,,,,,,,,,,,>).MakeGenericType(types);
case 13:
return typeof(Action<,,,,,,,,,,,,>).MakeGenericType(types);
case 14:
return typeof(Action<,,,,,,,,,,,,,>).MakeGenericType(types);
case 15:
return typeof(Action<,,,,,,,,,,,,,,>).MakeGenericType(types);
case 16:
return typeof(Action<,,,,,,,,,,,,,,,>).MakeGenericType(types);
default:
return null;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics;
using System.Dynamic.Utils;
namespace System.Linq.Expressions.Compiler
{
internal static partial class DelegateHelpers
{
/// <summary>
/// Finds a delegate type using the types in the array.
/// We use the cache to avoid copying the array, and to cache the
/// created delegate type
/// </summary>
internal static Type MakeDelegateType(Type[] types)
{
lock (_DelegateCache)
{
TypeInfo curTypeInfo = _DelegateCache;
// arguments & return type
for (int i = 0; i < types.Length; i++)
{
curTypeInfo = NextTypeInfo(types[i], curTypeInfo);
}
// see if we have the delegate already
if (curTypeInfo.DelegateType == null)
{
// clone because MakeCustomDelegate can hold onto the array.
curTypeInfo.DelegateType = MakeNewDelegate((Type[])types.Clone());
}
return curTypeInfo.DelegateType;
}
}
internal static TypeInfo NextTypeInfo(Type initialArg)
{
lock (_DelegateCache)
{
return NextTypeInfo(initialArg, _DelegateCache);
}
}
internal static TypeInfo GetNextTypeInfo(Type initialArg, TypeInfo curTypeInfo)
{
lock (_DelegateCache)
{
return NextTypeInfo(initialArg, curTypeInfo);
}
}
private static TypeInfo _DelegateCache = new TypeInfo();
private const int MaximumArity = 17;
internal sealed class TypeInfo
{
public Type DelegateType;
public Dictionary<Type, TypeInfo> TypeChain;
}
private static TypeInfo NextTypeInfo(Type initialArg, TypeInfo curTypeInfo)
{
Type lookingUp = initialArg;
TypeInfo nextTypeInfo;
if (curTypeInfo.TypeChain == null)
{
curTypeInfo.TypeChain = new Dictionary<Type, TypeInfo>();
}
if (!curTypeInfo.TypeChain.TryGetValue(lookingUp, out nextTypeInfo))
{
nextTypeInfo = new TypeInfo();
if (!lookingUp.IsCollectible)
{
curTypeInfo.TypeChain[lookingUp] = nextTypeInfo;
}
}
return nextTypeInfo;
}
public delegate object VBCallSiteDelegate0<T>(T callSite, object instance);
public delegate object VBCallSiteDelegate1<T>(T callSite, object instance, ref object arg1);
public delegate object VBCallSiteDelegate2<T>(T callSite, object instance, ref object arg1, ref object arg2);
public delegate object VBCallSiteDelegate3<T>(T callSite, object instance, ref object arg1, ref object arg2, ref object arg3);
public delegate object VBCallSiteDelegate4<T>(T callSite, object instance, ref object arg1, ref object arg2, ref object arg3, ref object arg4);
public delegate object VBCallSiteDelegate5<T>(T callSite, object instance, ref object arg1, ref object arg2, ref object arg3, ref object arg4, ref object arg5);
public delegate object VBCallSiteDelegate6<T>(T callSite, object instance, ref object arg1, ref object arg2, ref object arg3, ref object arg4, ref object arg5, ref object arg6);
public delegate object VBCallSiteDelegate7<T>(T callSite, object instance, ref object arg1, ref object arg2, ref object arg3, ref object arg4, ref object arg5, ref object arg6, ref object arg7);
private static Type TryMakeVBStyledCallSite(Type[] types)
{
// Shape of VB CallSiteDelegates is CallSite * (instance : obj) * [arg-n : byref obj] -> obj
// array of arguments should contain at least 3 elements (callsite, instance and return type)
if (types.Length < 3 || types[0].IsByRef || types[1] != typeof(object) || types[types.Length - 1] != typeof(object))
{
return null;
}
// check if all arguments starting from the second has type byref<obj>
for (int i = 2; i < types.Length - 2; ++i)
{
Type t = types[i];
if (!t.IsByRef || t.GetElementType() != typeof(object))
{
return null;
}
}
switch (types.Length - 1)
{
case 2: return typeof(VBCallSiteDelegate0<>).MakeGenericType(types[0]);
case 3: return typeof(VBCallSiteDelegate1<>).MakeGenericType(types[0]);
case 4: return typeof(VBCallSiteDelegate2<>).MakeGenericType(types[0]);
case 5: return typeof(VBCallSiteDelegate3<>).MakeGenericType(types[0]);
case 6: return typeof(VBCallSiteDelegate4<>).MakeGenericType(types[0]);
case 7: return typeof(VBCallSiteDelegate5<>).MakeGenericType(types[0]);
case 8: return typeof(VBCallSiteDelegate6<>).MakeGenericType(types[0]);
case 9: return typeof(VBCallSiteDelegate7<>).MakeGenericType(types[0]);
default: return null;
}
}
/// <summary>
/// Creates a new delegate, or uses a func/action
/// Note: this method does not cache
/// </summary>
internal static Type MakeNewDelegate(Type[] types)
{
Debug.Assert(types != null && types.Length > 0);
// Can only used predefined delegates if we have no byref types and
// the arity is small enough to fit in Func<...> or Action<...>
bool needCustom;
if (types.Length > MaximumArity)
{
needCustom = true;
}
else
{
needCustom = false;
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (type.IsByRef || type.IsByRefLike || type.IsPointer)
{
needCustom = true;
break;
}
}
}
if (needCustom)
{
if (LambdaExpression.CanCompileToIL)
{
return MakeNewCustomDelegate(types);
}
else
{
return TryMakeVBStyledCallSite(types) ?? MakeNewCustomDelegate(types);
}
}
Type result;
if (types[types.Length - 1] == typeof(void))
{
result = GetActionType(types.RemoveLast());
}
else
{
result = GetFuncType(types);
}
Debug.Assert(result != null);
return result;
}
internal static Type GetFuncType(Type[] types)
{
switch (types.Length)
{
case 1:
return typeof(Func<>).MakeGenericType(types);
case 2:
return typeof(Func<,>).MakeGenericType(types);
case 3:
return typeof(Func<,,>).MakeGenericType(types);
case 4:
return typeof(Func<,,,>).MakeGenericType(types);
case 5:
return typeof(Func<,,,,>).MakeGenericType(types);
case 6:
return typeof(Func<,,,,,>).MakeGenericType(types);
case 7:
return typeof(Func<,,,,,,>).MakeGenericType(types);
case 8:
return typeof(Func<,,,,,,,>).MakeGenericType(types);
case 9:
return typeof(Func<,,,,,,,,>).MakeGenericType(types);
case 10:
return typeof(Func<,,,,,,,,,>).MakeGenericType(types);
case 11:
return typeof(Func<,,,,,,,,,,>).MakeGenericType(types);
case 12:
return typeof(Func<,,,,,,,,,,,>).MakeGenericType(types);
case 13:
return typeof(Func<,,,,,,,,,,,,>).MakeGenericType(types);
case 14:
return typeof(Func<,,,,,,,,,,,,,>).MakeGenericType(types);
case 15:
return typeof(Func<,,,,,,,,,,,,,,>).MakeGenericType(types);
case 16:
return typeof(Func<,,,,,,,,,,,,,,,>).MakeGenericType(types);
case 17:
return typeof(Func<,,,,,,,,,,,,,,,,>).MakeGenericType(types);
default:
return null;
}
}
internal static Type GetActionType(Type[] types)
{
switch (types.Length)
{
case 0:
return typeof(Action);
case 1:
return typeof(Action<>).MakeGenericType(types);
case 2:
return typeof(Action<,>).MakeGenericType(types);
case 3:
return typeof(Action<,,>).MakeGenericType(types);
case 4:
return typeof(Action<,,,>).MakeGenericType(types);
case 5:
return typeof(Action<,,,,>).MakeGenericType(types);
case 6:
return typeof(Action<,,,,,>).MakeGenericType(types);
case 7:
return typeof(Action<,,,,,,>).MakeGenericType(types);
case 8:
return typeof(Action<,,,,,,,>).MakeGenericType(types);
case 9:
return typeof(Action<,,,,,,,,>).MakeGenericType(types);
case 10:
return typeof(Action<,,,,,,,,,>).MakeGenericType(types);
case 11:
return typeof(Action<,,,,,,,,,,>).MakeGenericType(types);
case 12:
return typeof(Action<,,,,,,,,,,,>).MakeGenericType(types);
case 13:
return typeof(Action<,,,,,,,,,,,,>).MakeGenericType(types);
case 14:
return typeof(Action<,,,,,,,,,,,,,>).MakeGenericType(types);
case 15:
return typeof(Action<,,,,,,,,,,,,,,>).MakeGenericType(types);
case 16:
return typeof(Action<,,,,,,,,,,,,,,,>).MakeGenericType(types);
default:
return null;
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightLogicalAdd.Vector64.UInt16.1.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void ShiftRightLogicalAdd_Vector64_UInt16_1()
{
var test = new ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle2;
private GCHandle outHandle;
private ulong alignment;
public DataTable(UInt16[] inArray1, UInt16[] inArray2, UInt16[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<UInt16>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<UInt16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<UInt16>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<UInt16, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<UInt16, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<UInt16> _fld1;
public Vector64<UInt16> _fld2;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref testStruct._fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref testStruct._fld2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
return testStruct;
}
public void RunStructFldScenario(ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1 testClass)
{
var result = AdvSimd.ShiftRightLogicalAdd(_fld1, _fld2, 1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1 testClass)
{
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector64<UInt16>* pFld2 = &_fld2)
{
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector64((UInt16*)(pFld2)),
1
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 8;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly byte Imm = 1;
private static UInt16[] _data1 = new UInt16[Op1ElementCount];
private static UInt16[] _data2 = new UInt16[Op2ElementCount];
private static Vector64<UInt16> _clsVar1;
private static Vector64<UInt16> _clsVar2;
private Vector64<UInt16> _fld1;
private Vector64<UInt16> _fld2;
private DataTable _dataTable;
static ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
}
public ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _fld2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetUInt16(); }
_dataTable = new DataTable(_data1, _data2, new UInt16[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.ShiftRightLogicalAdd(
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray2Ptr),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray2Ptr)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAdd), new Type[] { typeof(Vector64<UInt16>), typeof(Vector64<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray2Ptr),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAdd), new Type[] { typeof(Vector64<UInt16>), typeof(Vector64<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray2Ptr)),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.ShiftRightLogicalAdd(
_clsVar1,
_clsVar2,
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector64<UInt16>* pClsVar1 = &_clsVar1)
fixed (Vector64<UInt16>* pClsVar2 = &_clsVar2)
{
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(pClsVar1)),
AdvSimd.LoadVector64((UInt16*)(pClsVar2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray2Ptr);
var result = AdvSimd.ShiftRightLogicalAdd(op1, op2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray2Ptr));
var result = AdvSimd.ShiftRightLogicalAdd(op1, op2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1();
var result = AdvSimd.ShiftRightLogicalAdd(test._fld1, test._fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1();
fixed (Vector64<UInt16>* pFld1 = &test._fld1)
fixed (Vector64<UInt16>* pFld2 = &test._fld2)
{
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector64((UInt16*)(pFld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.ShiftRightLogicalAdd(_fld1, _fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector64<UInt16>* pFld2 = &_fld2)
{
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector64((UInt16*)(pFld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.ShiftRightLogicalAdd(test._fld1, test._fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(&test._fld1)),
AdvSimd.LoadVector64((UInt16*)(&test._fld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector64<UInt16> firstOp, Vector64<UInt16> secondOp, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] inArray2 = new UInt16[Op2ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), firstOp);
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray2[0]), secondOp);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(void* firstOp, void* secondOp, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] inArray2 = new UInt16[Op2ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(firstOp), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(secondOp), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.ShiftRightLogicalAdd(firstOp[i], secondOp[i], Imm) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightLogicalAdd)}<UInt16>(Vector64<UInt16>, Vector64<UInt16>, 1): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void ShiftRightLogicalAdd_Vector64_UInt16_1()
{
var test = new ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle2;
private GCHandle outHandle;
private ulong alignment;
public DataTable(UInt16[] inArray1, UInt16[] inArray2, UInt16[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<UInt16>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<UInt16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<UInt16>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<UInt16, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<UInt16, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector64<UInt16> _fld1;
public Vector64<UInt16> _fld2;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref testStruct._fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref testStruct._fld2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
return testStruct;
}
public void RunStructFldScenario(ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1 testClass)
{
var result = AdvSimd.ShiftRightLogicalAdd(_fld1, _fld2, 1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1 testClass)
{
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector64<UInt16>* pFld2 = &_fld2)
{
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector64((UInt16*)(pFld2)),
1
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 8;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<UInt16>>() / sizeof(UInt16);
private static readonly byte Imm = 1;
private static UInt16[] _data1 = new UInt16[Op1ElementCount];
private static UInt16[] _data2 = new UInt16[Op2ElementCount];
private static Vector64<UInt16> _clsVar1;
private static Vector64<UInt16> _clsVar2;
private Vector64<UInt16> _fld1;
private Vector64<UInt16> _fld2;
private DataTable _dataTable;
static ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
}
public ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _fld2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetUInt16(); }
_dataTable = new DataTable(_data1, _data2, new UInt16[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.ShiftRightLogicalAdd(
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray2Ptr),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray2Ptr)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAdd), new Type[] { typeof(Vector64<UInt16>), typeof(Vector64<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray2Ptr),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAdd), new Type[] { typeof(Vector64<UInt16>), typeof(Vector64<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray2Ptr)),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector64<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.ShiftRightLogicalAdd(
_clsVar1,
_clsVar2,
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector64<UInt16>* pClsVar1 = &_clsVar1)
fixed (Vector64<UInt16>* pClsVar2 = &_clsVar2)
{
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(pClsVar1)),
AdvSimd.LoadVector64((UInt16*)(pClsVar2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray2Ptr);
var result = AdvSimd.ShiftRightLogicalAdd(op1, op2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray2Ptr));
var result = AdvSimd.ShiftRightLogicalAdd(op1, op2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1();
var result = AdvSimd.ShiftRightLogicalAdd(test._fld1, test._fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new ImmBinaryOpTest__ShiftRightLogicalAdd_Vector64_UInt16_1();
fixed (Vector64<UInt16>* pFld1 = &test._fld1)
fixed (Vector64<UInt16>* pFld2 = &test._fld2)
{
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector64((UInt16*)(pFld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.ShiftRightLogicalAdd(_fld1, _fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector64<UInt16>* pFld2 = &_fld2)
{
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector64((UInt16*)(pFld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.ShiftRightLogicalAdd(test._fld1, test._fld2, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.ShiftRightLogicalAdd(
AdvSimd.LoadVector64((UInt16*)(&test._fld1)),
AdvSimd.LoadVector64((UInt16*)(&test._fld2)),
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector64<UInt16> firstOp, Vector64<UInt16> secondOp, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] inArray2 = new UInt16[Op2ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), firstOp);
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray2[0]), secondOp);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(void* firstOp, void* secondOp, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] inArray2 = new UInt16[Op2ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(firstOp), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(secondOp), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
ValidateResult(inArray1, inArray2, outArray, method);
}
private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.ShiftRightLogicalAdd(firstOp[i], secondOp[i], Imm) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightLogicalAdd)}<UInt16>(Vector64<UInt16>, Vector64<UInt16>, 1): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/Methodical/refany/array1.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>Full</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="array1.cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>Full</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="array1.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Security.Permissions/src/System/Security/Permissions/PermissionSetAttribute.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
namespace System.Security.Permissions
{
#if NETCOREAPP
[Obsolete(Obsoletions.CodeAccessSecurityMessage, DiagnosticId = Obsoletions.CodeAccessSecurityDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
#endif
[AttributeUsage((AttributeTargets)(109), AllowMultiple = true, Inherited = false)]
public sealed partial class PermissionSetAttribute : CodeAccessSecurityAttribute
{
public PermissionSetAttribute(SecurityAction action) : base(default(SecurityAction)) { }
public string File { get; set; }
public string Hex { get; set; }
public string Name { get; set; }
public bool UnicodeEncoded { get; set; }
public string XML { get; set; }
public override IPermission CreatePermission() { return default(IPermission); }
public PermissionSet CreatePermissionSet() { return default(PermissionSet); }
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
namespace System.Security.Permissions
{
#if NETCOREAPP
[Obsolete(Obsoletions.CodeAccessSecurityMessage, DiagnosticId = Obsoletions.CodeAccessSecurityDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
#endif
[AttributeUsage((AttributeTargets)(109), AllowMultiple = true, Inherited = false)]
public sealed partial class PermissionSetAttribute : CodeAccessSecurityAttribute
{
public PermissionSetAttribute(SecurityAction action) : base(default(SecurityAction)) { }
public string File { get; set; }
public string Hex { get; set; }
public string Name { get; set; }
public bool UnicodeEncoded { get; set; }
public string XML { get; set; }
public override IPermission CreatePermission() { return default(IPermission); }
public PermissionSet CreatePermissionSet() { return default(PermissionSet); }
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Private.Xml/src/System/Xml/Xslt/XsltException.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Resources;
using System.Runtime.Serialization;
using System.Xml.XPath;
namespace System.Xml.Xsl
{
[Serializable]
[System.Runtime.CompilerServices.TypeForwardedFrom("System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public class XsltException : SystemException
{
private readonly string _res;
private readonly string[]? _args;
private readonly string? _sourceUri;
private readonly int _lineNumber;
private readonly int _linePosition;
// message != null for V1 & V2 exceptions deserialized in Whidbey
// message == null for created V2 exceptions; the exception message is stored in Exception._message
private readonly string? _message;
protected XsltException(SerializationInfo info, StreamingContext context) : base(info, context)
{
_res = (string)info.GetValue("res", typeof(string))!;
_args = (string[]?)info.GetValue("args", typeof(string[]));
_sourceUri = (string?)info.GetValue("sourceUri", typeof(string));
_lineNumber = (int)info.GetValue("lineNumber", typeof(int))!;
_linePosition = (int)info.GetValue("linePosition", typeof(int))!;
// deserialize optional members
string? version = null;
foreach (SerializationEntry e in info)
{
if (e.Name == "version")
{
version = (string?)e.Value;
}
}
if (version == null)
{
// deserializing V1 exception
_message = CreateMessage(_res, _args, _sourceUri, _lineNumber, _linePosition);
}
else
{
// deserializing V2 or higher exception -> exception message is serialized by the base class (Exception._message)
_message = null;
}
}
public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
base.GetObjectData(info, context);
info.AddValue("res", _res);
info.AddValue("args", _args);
info.AddValue("sourceUri", _sourceUri);
info.AddValue("lineNumber", _lineNumber);
info.AddValue("linePosition", _linePosition);
info.AddValue("version", "2.0");
}
public XsltException() : this(string.Empty, (Exception?)null) { }
public XsltException(string message) : this(message, (Exception?)null) { }
public XsltException(string message, Exception? innerException) :
this(SR.Xml_UserException, new string?[] { message }, null, 0, 0, innerException)
{
}
internal static XsltException Create(string res, params string?[] args)
{
return new XsltException(res, args, null, 0, 0, null);
}
internal static XsltException Create(string res, string?[] args, Exception inner)
{
return new XsltException(res, args, null, 0, 0, inner);
}
internal XsltException(string res, string?[] args, string? sourceUri, int lineNumber, int linePosition, Exception? inner)
: base(CreateMessage(res, args, sourceUri, lineNumber, linePosition), inner)
{
HResult = HResults.XmlXslt;
_res = res;
_sourceUri = sourceUri;
_lineNumber = lineNumber;
_linePosition = linePosition;
}
public virtual string? SourceUri
{
get { return _sourceUri; }
}
public virtual int LineNumber
{
get { return _lineNumber; }
}
public virtual int LinePosition
{
get { return _linePosition; }
}
public override string Message
{
get
{
return _message ?? base.Message;
}
}
private static string CreateMessage(string res, string?[]? args, string? sourceUri, int lineNumber, int linePosition)
{
try
{
string message = FormatMessage(res, args);
if (res != SR.Xslt_CompileError && lineNumber != 0)
{
message += $" {FormatMessage(SR.Xml_ErrorFilePosition, sourceUri, lineNumber.ToString(CultureInfo.InvariantCulture), linePosition.ToString(CultureInfo.InvariantCulture))}";
}
return message;
}
catch (MissingManifestResourceException)
{
return $"UNKNOWN({res})";
}
}
[return: NotNullIfNotNull("key")]
private static string? FormatMessage(string? key, params string?[]? args)
{
string? message = key;
if (message != null && args != null)
{
message = string.Format(CultureInfo.InvariantCulture, message, args);
}
return message;
}
}
[Serializable]
[System.Runtime.CompilerServices.TypeForwardedFrom("System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public class XsltCompileException : XsltException
{
protected XsltCompileException(SerializationInfo info, StreamingContext context) : base(info, context)
{
}
public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
base.GetObjectData(info, context);
}
public XsltCompileException() : base() { }
public XsltCompileException(string message) : base(message) { }
public XsltCompileException(string message, Exception innerException) : base(message, innerException) { }
public XsltCompileException(Exception inner, string sourceUri, int lineNumber, int linePosition) :
base(
lineNumber != 0 ? SR.Xslt_CompileError : SR.Xslt_CompileError2,
new string[] { sourceUri, lineNumber.ToString(CultureInfo.InvariantCulture), linePosition.ToString(CultureInfo.InvariantCulture) },
sourceUri, lineNumber, linePosition, inner
)
{ }
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Resources;
using System.Runtime.Serialization;
using System.Xml.XPath;
namespace System.Xml.Xsl
{
[Serializable]
[System.Runtime.CompilerServices.TypeForwardedFrom("System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public class XsltException : SystemException
{
private readonly string _res;
private readonly string[]? _args;
private readonly string? _sourceUri;
private readonly int _lineNumber;
private readonly int _linePosition;
// message != null for V1 & V2 exceptions deserialized in Whidbey
// message == null for created V2 exceptions; the exception message is stored in Exception._message
private readonly string? _message;
protected XsltException(SerializationInfo info, StreamingContext context) : base(info, context)
{
_res = (string)info.GetValue("res", typeof(string))!;
_args = (string[]?)info.GetValue("args", typeof(string[]));
_sourceUri = (string?)info.GetValue("sourceUri", typeof(string));
_lineNumber = (int)info.GetValue("lineNumber", typeof(int))!;
_linePosition = (int)info.GetValue("linePosition", typeof(int))!;
// deserialize optional members
string? version = null;
foreach (SerializationEntry e in info)
{
if (e.Name == "version")
{
version = (string?)e.Value;
}
}
if (version == null)
{
// deserializing V1 exception
_message = CreateMessage(_res, _args, _sourceUri, _lineNumber, _linePosition);
}
else
{
// deserializing V2 or higher exception -> exception message is serialized by the base class (Exception._message)
_message = null;
}
}
public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
base.GetObjectData(info, context);
info.AddValue("res", _res);
info.AddValue("args", _args);
info.AddValue("sourceUri", _sourceUri);
info.AddValue("lineNumber", _lineNumber);
info.AddValue("linePosition", _linePosition);
info.AddValue("version", "2.0");
}
public XsltException() : this(string.Empty, (Exception?)null) { }
public XsltException(string message) : this(message, (Exception?)null) { }
public XsltException(string message, Exception? innerException) :
this(SR.Xml_UserException, new string?[] { message }, null, 0, 0, innerException)
{
}
internal static XsltException Create(string res, params string?[] args)
{
return new XsltException(res, args, null, 0, 0, null);
}
internal static XsltException Create(string res, string?[] args, Exception inner)
{
return new XsltException(res, args, null, 0, 0, inner);
}
internal XsltException(string res, string?[] args, string? sourceUri, int lineNumber, int linePosition, Exception? inner)
: base(CreateMessage(res, args, sourceUri, lineNumber, linePosition), inner)
{
HResult = HResults.XmlXslt;
_res = res;
_sourceUri = sourceUri;
_lineNumber = lineNumber;
_linePosition = linePosition;
}
public virtual string? SourceUri
{
get { return _sourceUri; }
}
public virtual int LineNumber
{
get { return _lineNumber; }
}
public virtual int LinePosition
{
get { return _linePosition; }
}
public override string Message
{
get
{
return _message ?? base.Message;
}
}
private static string CreateMessage(string res, string?[]? args, string? sourceUri, int lineNumber, int linePosition)
{
try
{
string message = FormatMessage(res, args);
if (res != SR.Xslt_CompileError && lineNumber != 0)
{
message += $" {FormatMessage(SR.Xml_ErrorFilePosition, sourceUri, lineNumber.ToString(CultureInfo.InvariantCulture), linePosition.ToString(CultureInfo.InvariantCulture))}";
}
return message;
}
catch (MissingManifestResourceException)
{
return $"UNKNOWN({res})";
}
}
[return: NotNullIfNotNull("key")]
private static string? FormatMessage(string? key, params string?[]? args)
{
string? message = key;
if (message != null && args != null)
{
message = string.Format(CultureInfo.InvariantCulture, message, args);
}
return message;
}
}
[Serializable]
[System.Runtime.CompilerServices.TypeForwardedFrom("System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public class XsltCompileException : XsltException
{
protected XsltCompileException(SerializationInfo info, StreamingContext context) : base(info, context)
{
}
public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
base.GetObjectData(info, context);
}
public XsltCompileException() : base() { }
public XsltCompileException(string message) : base(message) { }
public XsltCompileException(string message, Exception innerException) : base(message, innerException) { }
public XsltCompileException(Exception inner, string sourceUri, int lineNumber, int linePosition) :
base(
lineNumber != 0 ? SR.Xslt_CompileError : SR.Xslt_CompileError2,
new string[] { sourceUri, lineNumber.ToString(CultureInfo.InvariantCulture), linePosition.ToString(CultureInfo.InvariantCulture) },
sourceUri, lineNumber, linePosition, inner
)
{ }
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/jit64/valuetypes/nullable/castclass/null/castclass-null006.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.InteropServices;
using System;
internal class NullableTest
{
private static bool BoxUnboxToNQGen<T>(T o)
{
return ((ValueType)(object)o) == null;
}
private static bool BoxUnboxToQGen<T>(T? o) where T : struct
{
return ((T?)(object)(ValueType)o) == null;
}
private static bool BoxUnboxToNQ(object o)
{
return ((ValueType)o) == null;
}
private static bool BoxUnboxToQ(object o)
{
return ((ushort?)(ValueType)o) == null;
}
private static int Main()
{
ushort? s = null;
if (BoxUnboxToNQ(s) && BoxUnboxToQ(s) && BoxUnboxToNQGen(s) && BoxUnboxToQGen(s))
return ExitCode.Passed;
else
return ExitCode.Failed;
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.InteropServices;
using System;
internal class NullableTest
{
private static bool BoxUnboxToNQGen<T>(T o)
{
return ((ValueType)(object)o) == null;
}
private static bool BoxUnboxToQGen<T>(T? o) where T : struct
{
return ((T?)(object)(ValueType)o) == null;
}
private static bool BoxUnboxToNQ(object o)
{
return ((ValueType)o) == null;
}
private static bool BoxUnboxToQ(object o)
{
return ((ushort?)(ValueType)o) == null;
}
private static int Main()
{
ushort? s = null;
if (BoxUnboxToNQ(s) && BoxUnboxToQ(s) && BoxUnboxToNQGen(s) && BoxUnboxToQGen(s))
return ExitCode.Passed;
else
return ExitCode.Failed;
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/MultiplyBySelectedScalarWideningLowerAndAdd.Vector64.Int16.Vector64.Int16.3.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3()
{
var test = new SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private byte[] inArray3;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle2;
private GCHandle inHandle3;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Int32[] inArray1, Int16[] inArray2, Int16[] inArray3, Int32[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Int32>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<Int16>();
int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<Int16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Int32>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.inArray3 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Int32, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<Int16, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<Int16, byte>(ref inArray3[0]), (uint)sizeOfinArray3);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
inHandle3.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<Int32> _fld1;
public Vector64<Int16> _fld2;
public Vector64<Int16> _fld3;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref testStruct._fld1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref testStruct._fld2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref testStruct._fld3), ref Unsafe.As<Int16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
return testStruct;
}
public void RunStructFldScenario(SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3 testClass)
{
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(_fld1, _fld2, _fld3, 3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3 testClass)
{
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector64<Int16>* pFld2 = &_fld2)
fixed (Vector64<Int16>* pFld3 = &_fld3)
{
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector64((Int16*)(pFld2)),
AdvSimd.LoadVector64((Int16*)(pFld3)),
3
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<Int32>>() / sizeof(Int32);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector64<Int16>>() / sizeof(Int16);
private static readonly int Op3ElementCount = Unsafe.SizeOf<Vector64<Int16>>() / sizeof(Int16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector128<Int32>>() / sizeof(Int32);
private static readonly byte Imm = 3;
private static Int32[] _data1 = new Int32[Op1ElementCount];
private static Int16[] _data2 = new Int16[Op2ElementCount];
private static Int16[] _data3 = new Int16[Op3ElementCount];
private static Vector128<Int32> _clsVar1;
private static Vector64<Int16> _clsVar2;
private static Vector64<Int16> _clsVar3;
private Vector128<Int32> _fld1;
private Vector64<Int16> _fld2;
private Vector64<Int16> _fld3;
private DataTable _dataTable;
static SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _clsVar2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _clsVar3), ref Unsafe.As<Int16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
}
public SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _fld1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _fld2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _fld3), ref Unsafe.As<Int16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetInt16(); }
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt16(); }
_dataTable = new DataTable(_data1, _data2, _data3, new Int32[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray3Ptr),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray3Ptr)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd), new Type[] { typeof(Vector128<Int32>), typeof(Vector64<Int16>), typeof(Vector64<Int16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray3Ptr),
(byte)3
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd), new Type[] { typeof(Vector128<Int32>), typeof(Vector64<Int16>), typeof(Vector64<Int16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray3Ptr)),
(byte)3
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
_clsVar1,
_clsVar2,
_clsVar3,
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _clsVar3, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<Int32>* pClsVar1 = &_clsVar1)
fixed (Vector64<Int16>* pClsVar2 = &_clsVar2)
fixed (Vector64<Int16>* pClsVar3 = &_clsVar3)
{
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(pClsVar1)),
AdvSimd.LoadVector64((Int16*)(pClsVar2)),
AdvSimd.LoadVector64((Int16*)(pClsVar3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _clsVar3, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<Int16>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector64<Int16>>(_dataTable.inArray3Ptr);
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(op1, op2, op3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray3Ptr));
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(op1, op2, op3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3();
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(test._fld1, test._fld2, test._fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3();
fixed (Vector128<Int32>* pFld1 = &test._fld1)
fixed (Vector64<Int16>* pFld2 = &test._fld2)
fixed (Vector64<Int16>* pFld3 = &test._fld3)
{
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector64((Int16*)(pFld2)),
AdvSimd.LoadVector64((Int16*)(pFld3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(_fld1, _fld2, _fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector64<Int16>* pFld2 = &_fld2)
fixed (Vector64<Int16>* pFld3 = &_fld3)
{
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector64((Int16*)(pFld2)),
AdvSimd.LoadVector64((Int16*)(pFld3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(test._fld1, test._fld2, test._fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(&test._fld1)),
AdvSimd.LoadVector64((Int16*)(&test._fld2)),
AdvSimd.LoadVector64((Int16*)(&test._fld3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<Int32> op1, Vector64<Int16> op2, Vector64<Int16> op3, void* result, [CallerMemberName] string method = "")
{
Int32[] inArray1 = new Int32[Op1ElementCount];
Int16[] inArray2 = new Int16[Op2ElementCount];
Int16[] inArray3 = new Int16[Op3ElementCount];
Int32[] outArray = new Int32[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Int32, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<Int16, byte>(ref inArray2[0]), op2);
Unsafe.WriteUnaligned(ref Unsafe.As<Int16, byte>(ref inArray3[0]), op3);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int32>>());
ValidateResult(inArray1, inArray2, inArray3, outArray, method);
}
private void ValidateResult(void* op1, void* op2, void* op3, void* result, [CallerMemberName] string method = "")
{
Int32[] inArray1 = new Int32[Op1ElementCount];
Int16[] inArray2 = new Int16[Op2ElementCount];
Int16[] inArray3 = new Int16[Op3ElementCount];
Int32[] outArray = new Int32[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<Vector64<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<Vector64<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int32>>());
ValidateResult(inArray1, inArray2, inArray3, outArray, method);
}
private void ValidateResult(Int32[] firstOp, Int16[] secondOp, Int16[] thirdOp, Int32[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.MultiplyWideningAndAdd(firstOp[i], secondOp[i], thirdOp[Imm]) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd)}<Int32>(Vector128<Int32>, Vector64<Int16>, Vector64<Int16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3()
{
var test = new SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray2;
private byte[] inArray3;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle2;
private GCHandle inHandle3;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Int32[] inArray1, Int16[] inArray2, Int16[] inArray3, Int32[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Int32>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<Int16>();
int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<Int16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Int32>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray2 = new byte[alignment * 2];
this.inArray3 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Int32, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<Int16, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<Int16, byte>(ref inArray3[0]), (uint)sizeOfinArray3);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle2.Free();
inHandle3.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<Int32> _fld1;
public Vector64<Int16> _fld2;
public Vector64<Int16> _fld3;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref testStruct._fld1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref testStruct._fld2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref testStruct._fld3), ref Unsafe.As<Int16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
return testStruct;
}
public void RunStructFldScenario(SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3 testClass)
{
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(_fld1, _fld2, _fld3, 3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3 testClass)
{
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector64<Int16>* pFld2 = &_fld2)
fixed (Vector64<Int16>* pFld3 = &_fld3)
{
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector64((Int16*)(pFld2)),
AdvSimd.LoadVector64((Int16*)(pFld3)),
3
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<Int32>>() / sizeof(Int32);
private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector64<Int16>>() / sizeof(Int16);
private static readonly int Op3ElementCount = Unsafe.SizeOf<Vector64<Int16>>() / sizeof(Int16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector128<Int32>>() / sizeof(Int32);
private static readonly byte Imm = 3;
private static Int32[] _data1 = new Int32[Op1ElementCount];
private static Int16[] _data2 = new Int16[Op2ElementCount];
private static Int16[] _data3 = new Int16[Op3ElementCount];
private static Vector128<Int32> _clsVar1;
private static Vector64<Int16> _clsVar2;
private static Vector64<Int16> _clsVar3;
private Vector128<Int32> _fld1;
private Vector64<Int16> _fld2;
private Vector64<Int16> _fld3;
private DataTable _dataTable;
static SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _clsVar2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _clsVar3), ref Unsafe.As<Int16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
}
public SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _fld1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _fld2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _fld3), ref Unsafe.As<Int16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetInt16(); }
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt16(); }
_dataTable = new DataTable(_data1, _data2, _data3, new Int32[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray3Ptr),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray3Ptr)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd), new Type[] { typeof(Vector128<Int32>), typeof(Vector64<Int16>), typeof(Vector64<Int16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray3Ptr),
(byte)3
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd), new Type[] { typeof(Vector128<Int32>), typeof(Vector64<Int16>), typeof(Vector64<Int16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray3Ptr)),
(byte)3
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
_clsVar1,
_clsVar2,
_clsVar3,
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _clsVar3, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<Int32>* pClsVar1 = &_clsVar1)
fixed (Vector64<Int16>* pClsVar2 = &_clsVar2)
fixed (Vector64<Int16>* pClsVar3 = &_clsVar3)
{
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(pClsVar1)),
AdvSimd.LoadVector64((Int16*)(pClsVar2)),
AdvSimd.LoadVector64((Int16*)(pClsVar3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _clsVar3, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<Int16>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector64<Int16>>(_dataTable.inArray3Ptr);
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(op1, op2, op3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray3Ptr));
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(op1, op2, op3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3();
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(test._fld1, test._fld2, test._fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleTernaryOpTest__MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_Int16_Vector64_Int16_3();
fixed (Vector128<Int32>* pFld1 = &test._fld1)
fixed (Vector64<Int16>* pFld2 = &test._fld2)
fixed (Vector64<Int16>* pFld3 = &test._fld3)
{
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector64((Int16*)(pFld2)),
AdvSimd.LoadVector64((Int16*)(pFld3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(_fld1, _fld2, _fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector64<Int16>* pFld2 = &_fld2)
fixed (Vector64<Int16>* pFld3 = &_fld3)
{
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector64((Int16*)(pFld2)),
AdvSimd.LoadVector64((Int16*)(pFld3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(test._fld1, test._fld2, test._fld3, 3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd(
AdvSimd.LoadVector128((Int32*)(&test._fld1)),
AdvSimd.LoadVector64((Int16*)(&test._fld2)),
AdvSimd.LoadVector64((Int16*)(&test._fld3)),
3
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<Int32> op1, Vector64<Int16> op2, Vector64<Int16> op3, void* result, [CallerMemberName] string method = "")
{
Int32[] inArray1 = new Int32[Op1ElementCount];
Int16[] inArray2 = new Int16[Op2ElementCount];
Int16[] inArray3 = new Int16[Op3ElementCount];
Int32[] outArray = new Int32[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Int32, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<Int16, byte>(ref inArray2[0]), op2);
Unsafe.WriteUnaligned(ref Unsafe.As<Int16, byte>(ref inArray3[0]), op3);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int32>>());
ValidateResult(inArray1, inArray2, inArray3, outArray, method);
}
private void ValidateResult(void* op1, void* op2, void* op3, void* result, [CallerMemberName] string method = "")
{
Int32[] inArray1 = new Int32[Op1ElementCount];
Int16[] inArray2 = new Int16[Op2ElementCount];
Int16[] inArray3 = new Int16[Op3ElementCount];
Int32[] outArray = new Int32[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<Vector64<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<Vector64<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int32>>());
ValidateResult(inArray1, inArray2, inArray3, outArray, method);
}
private void ValidateResult(Int32[] firstOp, Int16[] secondOp, Int16[] thirdOp, Int32[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.MultiplyWideningAndAdd(firstOp[i], secondOp[i], thirdOp[Imm]) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd)}<Int32>(Vector128<Int32>, Vector64<Int16>, Vector64<Int16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/Loader/classloader/v1/Beta1/Layout/Matrix/cs/L-2-5-3.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
<Compile Include="L-2-5-3.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="L-2-5-3D.csproj" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
<Compile Include="L-2-5-3.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="L-2-5-3D.csproj" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd.Arm64/InsertSelectedScalar.Vector128.Byte.15.Vector64.Byte.7.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7()
{
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray3;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle3;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Byte[] inArray1, Byte[] inArray3, Byte[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Byte>();
int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<Byte>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Byte>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray3 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Byte, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<Byte, byte>(ref inArray3[0]), (uint)sizeOfinArray3);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle3.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<Byte> _fld1;
public Vector64<Byte> _fld3;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Byte>, byte>(ref testStruct._fld1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Byte>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref testStruct._fld3), ref Unsafe.As<Byte, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
return testStruct;
}
public void RunStructFldScenario(InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7 testClass)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(_fld1, 15, _fld3, 7);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7 testClass)
{
fixed (Vector128<Byte>* pFld1 = &_fld1)
fixed (Vector64<Byte>* pFld2 = &_fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)pFld1),
15,
AdvSimd.LoadVector64((Byte*)pFld2),
7
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<Byte>>() / sizeof(Byte);
private static readonly int Op3ElementCount = Unsafe.SizeOf<Vector64<Byte>>() / sizeof(Byte);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector128<Byte>>() / sizeof(Byte);
private static readonly byte ElementIndex1 = 15;
private static readonly byte ElementIndex2 = 7;
private static Byte[] _data1 = new Byte[Op1ElementCount];
private static Byte[] _data3 = new Byte[Op3ElementCount];
private static Vector128<Byte> _clsVar1;
private static Vector64<Byte> _clsVar3;
private Vector128<Byte> _fld1;
private Vector64<Byte> _fld3;
private DataTable _dataTable;
static InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Byte>, byte>(ref _clsVar1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Byte>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _clsVar3), ref Unsafe.As<Byte, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
}
public InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Byte>, byte>(ref _fld1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Byte>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _fld3), ref Unsafe.As<Byte, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetByte(); }
_dataTable = new DataTable(_data1, _data3, new Byte[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.Arm64.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.Arm64.InsertSelectedScalar(
Unsafe.Read<Vector128<Byte>>(_dataTable.inArray1Ptr),
15,
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray3Ptr),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)),
15,
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray3Ptr)),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.InsertSelectedScalar), new Type[] { typeof(Vector128<Byte>), typeof(byte), typeof(Vector64<Byte>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Byte>>(_dataTable.inArray1Ptr),
ElementIndex1,
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray3Ptr),
ElementIndex2
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Byte>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.InsertSelectedScalar), new Type[] { typeof(Vector128<Byte>), typeof(byte), typeof(Vector64<Byte>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)),
ElementIndex1,
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray3Ptr)),
ElementIndex2
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Byte>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.Arm64.InsertSelectedScalar(
_clsVar1,
15,
_clsVar3,
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<Byte>* pClsVar1 = &_clsVar1)
fixed (Vector64<Byte>* pClsVar3 = &_clsVar3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)(pClsVar1)),
15,
AdvSimd.LoadVector64((Byte*)(pClsVar3)),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector128<Byte>>(_dataTable.inArray1Ptr);
var op3 = Unsafe.Read<Vector64<Byte>>(_dataTable.inArray3Ptr);
var result = AdvSimd.Arm64.InsertSelectedScalar(op1, 15, op3, 7);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op3, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr));
var op3 = AdvSimd.LoadVector64((Byte*)(_dataTable.inArray3Ptr));
var result = AdvSimd.Arm64.InsertSelectedScalar(op1, 15, op3, 7);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7();
var result = AdvSimd.Arm64.InsertSelectedScalar(test._fld1, 15, test._fld3, 7);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7();
fixed (Vector128<Byte>* pFld1 = &test._fld1)
fixed (Vector64<Byte>* pFld2 = &test._fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)pFld1),
15,
AdvSimd.LoadVector64((Byte*)pFld2),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.Arm64.InsertSelectedScalar(_fld1, 15, _fld3, 7);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<Byte>* pFld1 = &_fld1)
fixed (Vector64<Byte>* pFld2 = &_fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)pFld1),
15,
AdvSimd.LoadVector64((Byte*)pFld2),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.InsertSelectedScalar(test._fld1, 15, test._fld3, 7);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)(&test._fld1)),
15,
AdvSimd.LoadVector64((Byte*)(&test._fld3)),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<Byte> op1, Vector64<Byte> op3, void* result, [CallerMemberName] string method = "")
{
Byte[] inArray1 = new Byte[Op1ElementCount];
Byte[] inArray3 = new Byte[Op3ElementCount];
Byte[] outArray = new Byte[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<Byte, byte>(ref inArray3[0]), op3);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Byte>>());
ValidateResult(inArray1, inArray3, outArray, method);
}
private void ValidateResult(void* op1, void* op3, void* result, [CallerMemberName] string method = "")
{
Byte[] inArray1 = new Byte[Op1ElementCount];
Byte[] inArray3 = new Byte[Op3ElementCount];
Byte[] outArray = new Byte[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<Vector64<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Byte>>());
ValidateResult(inArray1, inArray3, outArray, method);
}
private void ValidateResult(Byte[] firstOp, Byte[] thirdOp, Byte[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.Insert(firstOp, ElementIndex1, thirdOp[ElementIndex2], i) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd.Arm64)}.{nameof(AdvSimd.Arm64.InsertSelectedScalar)}<Byte>(Vector128<Byte>, {15}, Vector64<Byte>, {7}): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7()
{
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7
{
private struct DataTable
{
private byte[] inArray1;
private byte[] inArray3;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle inHandle3;
private GCHandle outHandle;
private ulong alignment;
public DataTable(Byte[] inArray1, Byte[] inArray3, Byte[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Byte>();
int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<Byte>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Byte>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.inArray3 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Byte, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<Byte, byte>(ref inArray3[0]), (uint)sizeOfinArray3);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
inHandle3.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<Byte> _fld1;
public Vector64<Byte> _fld3;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Byte>, byte>(ref testStruct._fld1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Byte>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref testStruct._fld3), ref Unsafe.As<Byte, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
return testStruct;
}
public void RunStructFldScenario(InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7 testClass)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(_fld1, 15, _fld3, 7);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7 testClass)
{
fixed (Vector128<Byte>* pFld1 = &_fld1)
fixed (Vector64<Byte>* pFld2 = &_fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)pFld1),
15,
AdvSimd.LoadVector64((Byte*)pFld2),
7
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<Byte>>() / sizeof(Byte);
private static readonly int Op3ElementCount = Unsafe.SizeOf<Vector64<Byte>>() / sizeof(Byte);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector128<Byte>>() / sizeof(Byte);
private static readonly byte ElementIndex1 = 15;
private static readonly byte ElementIndex2 = 7;
private static Byte[] _data1 = new Byte[Op1ElementCount];
private static Byte[] _data3 = new Byte[Op3ElementCount];
private static Vector128<Byte> _clsVar1;
private static Vector64<Byte> _clsVar3;
private Vector128<Byte> _fld1;
private Vector64<Byte> _fld3;
private DataTable _dataTable;
static InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Byte>, byte>(ref _clsVar1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Byte>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _clsVar3), ref Unsafe.As<Byte, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
}
public InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Byte>, byte>(ref _fld1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Byte>>());
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _fld3), ref Unsafe.As<Byte, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetByte(); }
_dataTable = new DataTable(_data1, _data3, new Byte[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.Arm64.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.Arm64.InsertSelectedScalar(
Unsafe.Read<Vector128<Byte>>(_dataTable.inArray1Ptr),
15,
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray3Ptr),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)),
15,
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray3Ptr)),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.InsertSelectedScalar), new Type[] { typeof(Vector128<Byte>), typeof(byte), typeof(Vector64<Byte>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Byte>>(_dataTable.inArray1Ptr),
ElementIndex1,
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray3Ptr),
ElementIndex2
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Byte>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.InsertSelectedScalar), new Type[] { typeof(Vector128<Byte>), typeof(byte), typeof(Vector64<Byte>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)),
ElementIndex1,
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray3Ptr)),
ElementIndex2
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Byte>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.Arm64.InsertSelectedScalar(
_clsVar1,
15,
_clsVar3,
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<Byte>* pClsVar1 = &_clsVar1)
fixed (Vector64<Byte>* pClsVar3 = &_clsVar3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)(pClsVar1)),
15,
AdvSimd.LoadVector64((Byte*)(pClsVar3)),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector128<Byte>>(_dataTable.inArray1Ptr);
var op3 = Unsafe.Read<Vector64<Byte>>(_dataTable.inArray3Ptr);
var result = AdvSimd.Arm64.InsertSelectedScalar(op1, 15, op3, 7);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op3, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr));
var op3 = AdvSimd.LoadVector64((Byte*)(_dataTable.inArray3Ptr));
var result = AdvSimd.Arm64.InsertSelectedScalar(op1, 15, op3, 7);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7();
var result = AdvSimd.Arm64.InsertSelectedScalar(test._fld1, 15, test._fld3, 7);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new InsertSelectedScalarTest__InsertSelectedScalar_Vector128_Byte_15_Vector64_Byte_7();
fixed (Vector128<Byte>* pFld1 = &test._fld1)
fixed (Vector64<Byte>* pFld2 = &test._fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)pFld1),
15,
AdvSimd.LoadVector64((Byte*)pFld2),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.Arm64.InsertSelectedScalar(_fld1, 15, _fld3, 7);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<Byte>* pFld1 = &_fld1)
fixed (Vector64<Byte>* pFld2 = &_fld3)
{
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)pFld1),
15,
AdvSimd.LoadVector64((Byte*)pFld2),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.InsertSelectedScalar(test._fld1, 15, test._fld3, 7);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.Arm64.InsertSelectedScalar(
AdvSimd.LoadVector128((Byte*)(&test._fld1)),
15,
AdvSimd.LoadVector64((Byte*)(&test._fld3)),
7
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<Byte> op1, Vector64<Byte> op3, void* result, [CallerMemberName] string method = "")
{
Byte[] inArray1 = new Byte[Op1ElementCount];
Byte[] inArray3 = new Byte[Op3ElementCount];
Byte[] outArray = new Byte[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), op1);
Unsafe.WriteUnaligned(ref Unsafe.As<Byte, byte>(ref inArray3[0]), op3);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Byte>>());
ValidateResult(inArray1, inArray3, outArray, method);
}
private void ValidateResult(void* op1, void* op3, void* result, [CallerMemberName] string method = "")
{
Byte[] inArray1 = new Byte[Op1ElementCount];
Byte[] inArray3 = new Byte[Op3ElementCount];
Byte[] outArray = new Byte[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<Vector64<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Byte>>());
ValidateResult(inArray1, inArray3, outArray, method);
}
private void ValidateResult(Byte[] firstOp, Byte[] thirdOp, Byte[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.Insert(firstOp, ElementIndex1, thirdOp[ElementIndex2], i) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd.Arm64)}.{nameof(AdvSimd.Arm64.InsertSelectedScalar)}<Byte>(Vector128<Byte>, {15}, Vector64<Byte>, {7}): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/EnvelopedCms.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Diagnostics;
using System.Security.Cryptography.X509Certificates;
using Internal.Cryptography;
namespace System.Security.Cryptography.Pkcs
{
public sealed class EnvelopedCms
{
//
// Constructors
//
public EnvelopedCms()
: this(new ContentInfo(Array.Empty<byte>()))
{
}
public EnvelopedCms(ContentInfo contentInfo)
: this(contentInfo, new AlgorithmIdentifier(Oids.Aes256CbcOid.CopyOid()))
{
}
public EnvelopedCms(ContentInfo contentInfo!!, AlgorithmIdentifier encryptionAlgorithm!!)
{
Version = 0; // It makes little sense to ask for a version before you've decoded, but since the .NET Framework returns 0 in that case, we will too.
ContentInfo = contentInfo;
ContentEncryptionAlgorithm = encryptionAlgorithm;
Certificates = new X509Certificate2Collection();
UnprotectedAttributes = new CryptographicAttributeObjectCollection();
_decryptorPal = null;
_lastCall = LastCall.Ctor;
}
//
// Latched properties.
// - For senders, the caller sets their values and they act as implicit inputs to the Encrypt() method.
// - For recipients, the Decode() and Decrypt() methods reset their values and the caller can inspect them if desired.
//
public int Version { get; private set; }
public ContentInfo ContentInfo { get; private set; }
public AlgorithmIdentifier ContentEncryptionAlgorithm { get; private set; }
public X509Certificate2Collection Certificates { get; private set; }
public CryptographicAttributeObjectCollection UnprotectedAttributes { get; private set; }
//
// Recipients invoke this property to retrieve the recipient information after a Decode() operation.
// Senders should not invoke this property.
//
public RecipientInfoCollection RecipientInfos
{
get
{
switch (_lastCall)
{
case LastCall.Ctor:
return new RecipientInfoCollection();
case LastCall.Encrypt:
throw PkcsPal.Instance.CreateRecipientInfosAfterEncryptException();
case LastCall.Decode:
case LastCall.Decrypt:
Debug.Assert(_decryptorPal != null);
return _decryptorPal.RecipientInfos;
default:
Debug.Fail($"Unexpected _lastCall value: {_lastCall}");
throw new InvalidOperationException();
}
}
}
//
// Encrypt() overloads. Senders invoke this to encrypt and encode a CMS. Afterward, invoke the Encode() method to retrieve the actual encoding.
//
public void Encrypt(CmsRecipient recipient!!)
{
Encrypt(new CmsRecipientCollection(recipient));
}
public void Encrypt(CmsRecipientCollection recipients!!)
{
// .NET Framework compat note: Unlike the desktop, we don't provide a free UI to select the recipient. The app must give it to us programmatically.
if (recipients.Count == 0)
throw new PlatformNotSupportedException(SR.Cryptography_Cms_NoRecipients);
if (_decryptorPal != null)
{
_decryptorPal.Dispose();
_decryptorPal = null;
}
_encodedMessage = PkcsPal.Instance.Encrypt(recipients, ContentInfo, ContentEncryptionAlgorithm, Certificates, UnprotectedAttributes);
_lastCall = LastCall.Encrypt;
}
//
// Senders invoke Encode() after a successful Encrypt() to retrieve the RFC-compliant on-the-wire representation.
//
public byte[] Encode()
{
if (_encodedMessage == null)
throw new InvalidOperationException(SR.Cryptography_Cms_MessageNotEncrypted);
return _encodedMessage.CloneByteArray();
}
//
// Recipients invoke Decode() to turn the on-the-wire representation into a usable EnvelopedCms instance. Next step is to call Decrypt().
//
public void Decode(byte[] encodedMessage!!)
{
Decode(new ReadOnlySpan<byte>(encodedMessage));
}
/// <summary>
/// Decodes the provided data as a CMS/PKCS#7 EnvelopedData message.
/// </summary>
/// <param name="encodedMessage">
/// The data to decode.
/// </param>
/// <exception cref="CryptographicException">
/// The <paramref name="encodedMessage"/> parameter was not successfully decoded.
/// </exception>
public void Decode(ReadOnlySpan<byte> encodedMessage)
{
if (_decryptorPal != null)
{
_decryptorPal.Dispose();
_decryptorPal = null;
}
int version;
ContentInfo contentInfo;
AlgorithmIdentifier contentEncryptionAlgorithm;
X509Certificate2Collection originatorCerts;
CryptographicAttributeObjectCollection unprotectedAttributes;
_decryptorPal = PkcsPal.Instance.Decode(encodedMessage, out version, out contentInfo, out contentEncryptionAlgorithm, out originatorCerts, out unprotectedAttributes);
Version = version;
ContentInfo = contentInfo;
ContentEncryptionAlgorithm = contentEncryptionAlgorithm;
Certificates = originatorCerts;
UnprotectedAttributes = unprotectedAttributes;
// .NET Framework compat: Encode() after a Decode() returns you the same thing that ContentInfo.Content does.
_encodedMessage = contentInfo.Content.CloneByteArray();
_lastCall = LastCall.Decode;
}
//
// Decrypt() overloads: Recipients invoke Decrypt() after a successful Decode(). Afterwards, invoke ContentInfo to get the decrypted content.
//
public void Decrypt()
{
DecryptContent(RecipientInfos, null);
}
public void Decrypt(RecipientInfo recipientInfo!!)
{
DecryptContent(new RecipientInfoCollection(recipientInfo), null);
}
public void Decrypt(RecipientInfo recipientInfo!!, X509Certificate2Collection extraStore!!)
{
DecryptContent(new RecipientInfoCollection(recipientInfo), extraStore);
}
public void Decrypt(X509Certificate2Collection extraStore!!)
{
DecryptContent(RecipientInfos, extraStore);
}
public void Decrypt(RecipientInfo recipientInfo!!, AsymmetricAlgorithm? privateKey)
{
CheckStateForDecryption();
X509Certificate2Collection extraStore = new X509Certificate2Collection();
ContentInfo? contentInfo = _decryptorPal!.TryDecrypt(
recipientInfo,
null,
privateKey,
Certificates,
extraStore,
out Exception? exception);
if (exception != null)
throw exception;
SetContentInfo(contentInfo!);
}
private void DecryptContent(RecipientInfoCollection recipientInfos, X509Certificate2Collection? extraStore)
{
CheckStateForDecryption();
extraStore = extraStore ?? new X509Certificate2Collection();
X509Certificate2Collection certs = new X509Certificate2Collection();
PkcsPal.Instance.AddCertsFromStoreForDecryption(certs);
certs.AddRange(extraStore);
X509Certificate2Collection originatorCerts = Certificates;
ContentInfo? newContentInfo = null;
Exception? exception = PkcsPal.Instance.CreateRecipientsNotFoundException();
foreach (RecipientInfo recipientInfo in recipientInfos)
{
X509Certificate2? cert = certs.TryFindMatchingCertificate(recipientInfo.RecipientIdentifier);
if (cert == null)
{
exception = PkcsPal.Instance.CreateRecipientsNotFoundException();
continue;
}
newContentInfo = _decryptorPal!.TryDecrypt(
recipientInfo,
cert,
null,
originatorCerts,
extraStore,
out exception);
if (exception != null)
continue;
break;
}
if (exception != null)
throw exception;
SetContentInfo(newContentInfo!);
}
private void CheckStateForDecryption()
{
switch (_lastCall)
{
case LastCall.Ctor:
throw new InvalidOperationException(SR.Cryptography_Cms_MessageNotEncrypted);
case LastCall.Encrypt:
throw PkcsPal.Instance.CreateDecryptAfterEncryptException();
case LastCall.Decrypt:
throw PkcsPal.Instance.CreateDecryptTwiceException();
case LastCall.Decode:
break; // This is the expected state.
default:
Debug.Fail($"Unexpected _lastCall value: {_lastCall}");
throw new InvalidOperationException();
}
}
private void SetContentInfo(ContentInfo contentInfo)
{
ContentInfo = contentInfo;
// .NET Framework compat: Encode() after a Decrypt() returns you the same thing that ContentInfo.Content does.
_encodedMessage = contentInfo.Content.CloneByteArray();
_lastCall = LastCall.Decrypt;
}
//
// Instance fields
//
private DecryptorPal? _decryptorPal;
private byte[]? _encodedMessage;
private LastCall _lastCall;
private enum LastCall
{
Ctor = 1,
Encrypt = 2,
Decode = 3,
Decrypt = 4,
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Diagnostics;
using System.Security.Cryptography.X509Certificates;
using Internal.Cryptography;
namespace System.Security.Cryptography.Pkcs
{
public sealed class EnvelopedCms
{
//
// Constructors
//
public EnvelopedCms()
: this(new ContentInfo(Array.Empty<byte>()))
{
}
public EnvelopedCms(ContentInfo contentInfo)
: this(contentInfo, new AlgorithmIdentifier(Oids.Aes256CbcOid.CopyOid()))
{
}
public EnvelopedCms(ContentInfo contentInfo!!, AlgorithmIdentifier encryptionAlgorithm!!)
{
Version = 0; // It makes little sense to ask for a version before you've decoded, but since the .NET Framework returns 0 in that case, we will too.
ContentInfo = contentInfo;
ContentEncryptionAlgorithm = encryptionAlgorithm;
Certificates = new X509Certificate2Collection();
UnprotectedAttributes = new CryptographicAttributeObjectCollection();
_decryptorPal = null;
_lastCall = LastCall.Ctor;
}
//
// Latched properties.
// - For senders, the caller sets their values and they act as implicit inputs to the Encrypt() method.
// - For recipients, the Decode() and Decrypt() methods reset their values and the caller can inspect them if desired.
//
public int Version { get; private set; }
public ContentInfo ContentInfo { get; private set; }
public AlgorithmIdentifier ContentEncryptionAlgorithm { get; private set; }
public X509Certificate2Collection Certificates { get; private set; }
public CryptographicAttributeObjectCollection UnprotectedAttributes { get; private set; }
//
// Recipients invoke this property to retrieve the recipient information after a Decode() operation.
// Senders should not invoke this property.
//
public RecipientInfoCollection RecipientInfos
{
get
{
switch (_lastCall)
{
case LastCall.Ctor:
return new RecipientInfoCollection();
case LastCall.Encrypt:
throw PkcsPal.Instance.CreateRecipientInfosAfterEncryptException();
case LastCall.Decode:
case LastCall.Decrypt:
Debug.Assert(_decryptorPal != null);
return _decryptorPal.RecipientInfos;
default:
Debug.Fail($"Unexpected _lastCall value: {_lastCall}");
throw new InvalidOperationException();
}
}
}
//
// Encrypt() overloads. Senders invoke this to encrypt and encode a CMS. Afterward, invoke the Encode() method to retrieve the actual encoding.
//
public void Encrypt(CmsRecipient recipient!!)
{
Encrypt(new CmsRecipientCollection(recipient));
}
public void Encrypt(CmsRecipientCollection recipients!!)
{
// .NET Framework compat note: Unlike the desktop, we don't provide a free UI to select the recipient. The app must give it to us programmatically.
if (recipients.Count == 0)
throw new PlatformNotSupportedException(SR.Cryptography_Cms_NoRecipients);
if (_decryptorPal != null)
{
_decryptorPal.Dispose();
_decryptorPal = null;
}
_encodedMessage = PkcsPal.Instance.Encrypt(recipients, ContentInfo, ContentEncryptionAlgorithm, Certificates, UnprotectedAttributes);
_lastCall = LastCall.Encrypt;
}
//
// Senders invoke Encode() after a successful Encrypt() to retrieve the RFC-compliant on-the-wire representation.
//
public byte[] Encode()
{
if (_encodedMessage == null)
throw new InvalidOperationException(SR.Cryptography_Cms_MessageNotEncrypted);
return _encodedMessage.CloneByteArray();
}
//
// Recipients invoke Decode() to turn the on-the-wire representation into a usable EnvelopedCms instance. Next step is to call Decrypt().
//
public void Decode(byte[] encodedMessage!!)
{
Decode(new ReadOnlySpan<byte>(encodedMessage));
}
/// <summary>
/// Decodes the provided data as a CMS/PKCS#7 EnvelopedData message.
/// </summary>
/// <param name="encodedMessage">
/// The data to decode.
/// </param>
/// <exception cref="CryptographicException">
/// The <paramref name="encodedMessage"/> parameter was not successfully decoded.
/// </exception>
public void Decode(ReadOnlySpan<byte> encodedMessage)
{
if (_decryptorPal != null)
{
_decryptorPal.Dispose();
_decryptorPal = null;
}
int version;
ContentInfo contentInfo;
AlgorithmIdentifier contentEncryptionAlgorithm;
X509Certificate2Collection originatorCerts;
CryptographicAttributeObjectCollection unprotectedAttributes;
_decryptorPal = PkcsPal.Instance.Decode(encodedMessage, out version, out contentInfo, out contentEncryptionAlgorithm, out originatorCerts, out unprotectedAttributes);
Version = version;
ContentInfo = contentInfo;
ContentEncryptionAlgorithm = contentEncryptionAlgorithm;
Certificates = originatorCerts;
UnprotectedAttributes = unprotectedAttributes;
// .NET Framework compat: Encode() after a Decode() returns you the same thing that ContentInfo.Content does.
_encodedMessage = contentInfo.Content.CloneByteArray();
_lastCall = LastCall.Decode;
}
//
// Decrypt() overloads: Recipients invoke Decrypt() after a successful Decode(). Afterwards, invoke ContentInfo to get the decrypted content.
//
public void Decrypt()
{
DecryptContent(RecipientInfos, null);
}
public void Decrypt(RecipientInfo recipientInfo!!)
{
DecryptContent(new RecipientInfoCollection(recipientInfo), null);
}
public void Decrypt(RecipientInfo recipientInfo!!, X509Certificate2Collection extraStore!!)
{
DecryptContent(new RecipientInfoCollection(recipientInfo), extraStore);
}
public void Decrypt(X509Certificate2Collection extraStore!!)
{
DecryptContent(RecipientInfos, extraStore);
}
public void Decrypt(RecipientInfo recipientInfo!!, AsymmetricAlgorithm? privateKey)
{
CheckStateForDecryption();
X509Certificate2Collection extraStore = new X509Certificate2Collection();
ContentInfo? contentInfo = _decryptorPal!.TryDecrypt(
recipientInfo,
null,
privateKey,
Certificates,
extraStore,
out Exception? exception);
if (exception != null)
throw exception;
SetContentInfo(contentInfo!);
}
private void DecryptContent(RecipientInfoCollection recipientInfos, X509Certificate2Collection? extraStore)
{
CheckStateForDecryption();
extraStore = extraStore ?? new X509Certificate2Collection();
X509Certificate2Collection certs = new X509Certificate2Collection();
PkcsPal.Instance.AddCertsFromStoreForDecryption(certs);
certs.AddRange(extraStore);
X509Certificate2Collection originatorCerts = Certificates;
ContentInfo? newContentInfo = null;
Exception? exception = PkcsPal.Instance.CreateRecipientsNotFoundException();
foreach (RecipientInfo recipientInfo in recipientInfos)
{
X509Certificate2? cert = certs.TryFindMatchingCertificate(recipientInfo.RecipientIdentifier);
if (cert == null)
{
exception = PkcsPal.Instance.CreateRecipientsNotFoundException();
continue;
}
newContentInfo = _decryptorPal!.TryDecrypt(
recipientInfo,
cert,
null,
originatorCerts,
extraStore,
out exception);
if (exception != null)
continue;
break;
}
if (exception != null)
throw exception;
SetContentInfo(newContentInfo!);
}
private void CheckStateForDecryption()
{
switch (_lastCall)
{
case LastCall.Ctor:
throw new InvalidOperationException(SR.Cryptography_Cms_MessageNotEncrypted);
case LastCall.Encrypt:
throw PkcsPal.Instance.CreateDecryptAfterEncryptException();
case LastCall.Decrypt:
throw PkcsPal.Instance.CreateDecryptTwiceException();
case LastCall.Decode:
break; // This is the expected state.
default:
Debug.Fail($"Unexpected _lastCall value: {_lastCall}");
throw new InvalidOperationException();
}
}
private void SetContentInfo(ContentInfo contentInfo)
{
ContentInfo = contentInfo;
// .NET Framework compat: Encode() after a Decrypt() returns you the same thing that ContentInfo.Content does.
_encodedMessage = contentInfo.Content.CloneByteArray();
_lastCall = LastCall.Decrypt;
}
//
// Instance fields
//
private DecryptorPal? _decryptorPal;
private byte[]? _encodedMessage;
private LastCall _lastCall;
private enum LastCall
{
Ctor = 1,
Encrypt = 2,
Decode = 3,
Decrypt = 4,
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Threading.Timer/ref/System.Threading.Timer.Forwards.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// ------------------------------------------------------------------------------
// Changes to this file must follow the https://aka.ms/api-review process.
// ------------------------------------------------------------------------------
[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Threading.Timer))]
[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Threading.TimerCallback))]
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// ------------------------------------------------------------------------------
// Changes to this file must follow the https://aka.ms/api-review process.
// ------------------------------------------------------------------------------
[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Threading.Timer))]
[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Threading.TimerCallback))]
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/CopiedMetadataBlobNode.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Reflection.Metadata;
using System.Reflection.Metadata.Ecma335;
using Internal.Text;
using Internal.TypeSystem;
using Internal.TypeSystem.Ecma;
using Debug = System.Diagnostics.Debug;
namespace ILCompiler.DependencyAnalysis.ReadyToRun
{
/// <summary>
/// Copies the metadata blob from input MSIL assembly to output ready-to-run image, fixing up Rvas to
/// method IL bodies and FieldRvas.
/// </summary>
public class CopiedMetadataBlobNode : ObjectNode, ISymbolDefinitionNode
{
EcmaModule _sourceModule;
public CopiedMetadataBlobNode(EcmaModule sourceModule)
{
_sourceModule = sourceModule;
}
public override ObjectNodeSection Section => ObjectNodeSection.TextSection;
public override bool IsShareable => false;
public override int ClassCode => 635464644;
public override bool StaticDependenciesAreComputed => true;
public int Offset => 0;
public int Size => _sourceModule.PEReader.GetMetadata().Length;
private void WriteMethodTableRvas(NodeFactory factory, ref ObjectDataBuilder builder, ref BlobReader reader)
{
MetadataReader metadataReader = _sourceModule.MetadataReader;
var tableIndex = TableIndex.MethodDef;
int rowCount = metadataReader.GetTableRowCount(tableIndex);
int rowSize = metadataReader.GetTableRowSize(tableIndex);
for (int i = 1; i <= rowCount; i++)
{
Debug.Assert(builder.CountBytes == reader.Offset);
int inputRva = reader.ReadInt32();
if (inputRva == 0)
{
// Don't fix up 0 Rvas (abstract methods in the methodDef table)
builder.EmitInt(0);
}
else
{
var methodDefHandle = MetadataTokens.EntityHandle(TableIndex.MethodDef, i);
EcmaMethod method = _sourceModule.GetMethod(methodDefHandle) as EcmaMethod;
builder.EmitReloc(factory.CopiedMethodIL(method), RelocType.IMAGE_REL_BASED_ADDR32NB);
}
// Skip the rest of the row
int remainingBytes = rowSize - sizeof(int);
builder.EmitBytes(reader.ReadBytes(remainingBytes));
}
}
private void WriteFieldRvas(NodeFactory factory, ref ObjectDataBuilder builder, ref BlobReader reader)
{
MetadataReader metadataReader = _sourceModule.MetadataReader;
var tableIndex = TableIndex.FieldRva;
int rowCount = metadataReader.GetTableRowCount(tableIndex);
bool compressedFieldRef = 6 == metadataReader.GetTableRowSize(TableIndex.FieldRva);
for (int i = 1; i <= rowCount; i++)
{
Debug.Assert(builder.CountBytes == reader.Offset);
// Rva
reader.ReadInt32();
int fieldToken;
if (compressedFieldRef)
{
fieldToken = reader.ReadUInt16();
}
else
{
fieldToken = reader.ReadInt32();
}
EntityHandle fieldHandle = MetadataTokens.EntityHandle(TableIndex.Field, fieldToken);
EcmaField fieldDesc = (EcmaField)_sourceModule.GetField(fieldHandle);
Debug.Assert(fieldDesc.HasRva);
builder.EmitReloc(factory.CopiedFieldRva(fieldDesc), RelocType.IMAGE_REL_BASED_ADDR32NB);
if (compressedFieldRef)
{
builder.EmitUShort((ushort)fieldToken);
}
else
{
builder.EmitUInt((uint)fieldToken);
}
}
}
public unsafe override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
BlobReader metadataBlob = new BlobReader(_sourceModule.PEReader.GetMetadata().Pointer, _sourceModule.PEReader.GetMetadata().Length);
var metadataReader = _sourceModule.MetadataReader;
//
// methodDef table
//
int methodDefTableOffset = metadataReader.GetTableMetadataOffset(TableIndex.MethodDef);
builder.EmitBytes(metadataBlob.ReadBytes(methodDefTableOffset));
WriteMethodTableRvas(factory, ref builder, ref metadataBlob);
//
// fieldRva table
//
int fieldRvaTableOffset = metadataReader.GetTableMetadataOffset(TableIndex.FieldRva);
builder.EmitBytes(metadataBlob.ReadBytes(fieldRvaTableOffset - metadataBlob.Offset));
WriteFieldRvas(factory, ref builder, ref metadataBlob);
// Copy the rest of the metadata blob
builder.EmitBytes(metadataBlob.ReadBytes(metadataReader.MetadataLength - metadataBlob.Offset));
Debug.Assert(builder.CountBytes == metadataBlob.Length);
Debug.Assert(builder.CountBytes == metadataBlob.Offset);
Debug.Assert(builder.CountBytes == Size);
return builder.ToObjectData();
}
protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);
public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
{
sb.Append(nameMangler.CompilationUnitPrefix);
sb.Append("__MetadataBlob");
}
public override int CompareToImpl(ISortableNode other, CompilerComparer comparer)
{
return _sourceModule.CompareTo(((CopiedMetadataBlobNode)other)._sourceModule);
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Reflection.Metadata;
using System.Reflection.Metadata.Ecma335;
using Internal.Text;
using Internal.TypeSystem;
using Internal.TypeSystem.Ecma;
using Debug = System.Diagnostics.Debug;
namespace ILCompiler.DependencyAnalysis.ReadyToRun
{
/// <summary>
/// Copies the metadata blob from input MSIL assembly to output ready-to-run image, fixing up Rvas to
/// method IL bodies and FieldRvas.
/// </summary>
public class CopiedMetadataBlobNode : ObjectNode, ISymbolDefinitionNode
{
EcmaModule _sourceModule;
public CopiedMetadataBlobNode(EcmaModule sourceModule)
{
_sourceModule = sourceModule;
}
public override ObjectNodeSection Section => ObjectNodeSection.TextSection;
public override bool IsShareable => false;
public override int ClassCode => 635464644;
public override bool StaticDependenciesAreComputed => true;
public int Offset => 0;
public int Size => _sourceModule.PEReader.GetMetadata().Length;
private void WriteMethodTableRvas(NodeFactory factory, ref ObjectDataBuilder builder, ref BlobReader reader)
{
MetadataReader metadataReader = _sourceModule.MetadataReader;
var tableIndex = TableIndex.MethodDef;
int rowCount = metadataReader.GetTableRowCount(tableIndex);
int rowSize = metadataReader.GetTableRowSize(tableIndex);
for (int i = 1; i <= rowCount; i++)
{
Debug.Assert(builder.CountBytes == reader.Offset);
int inputRva = reader.ReadInt32();
if (inputRva == 0)
{
// Don't fix up 0 Rvas (abstract methods in the methodDef table)
builder.EmitInt(0);
}
else
{
var methodDefHandle = MetadataTokens.EntityHandle(TableIndex.MethodDef, i);
EcmaMethod method = _sourceModule.GetMethod(methodDefHandle) as EcmaMethod;
builder.EmitReloc(factory.CopiedMethodIL(method), RelocType.IMAGE_REL_BASED_ADDR32NB);
}
// Skip the rest of the row
int remainingBytes = rowSize - sizeof(int);
builder.EmitBytes(reader.ReadBytes(remainingBytes));
}
}
private void WriteFieldRvas(NodeFactory factory, ref ObjectDataBuilder builder, ref BlobReader reader)
{
MetadataReader metadataReader = _sourceModule.MetadataReader;
var tableIndex = TableIndex.FieldRva;
int rowCount = metadataReader.GetTableRowCount(tableIndex);
bool compressedFieldRef = 6 == metadataReader.GetTableRowSize(TableIndex.FieldRva);
for (int i = 1; i <= rowCount; i++)
{
Debug.Assert(builder.CountBytes == reader.Offset);
// Rva
reader.ReadInt32();
int fieldToken;
if (compressedFieldRef)
{
fieldToken = reader.ReadUInt16();
}
else
{
fieldToken = reader.ReadInt32();
}
EntityHandle fieldHandle = MetadataTokens.EntityHandle(TableIndex.Field, fieldToken);
EcmaField fieldDesc = (EcmaField)_sourceModule.GetField(fieldHandle);
Debug.Assert(fieldDesc.HasRva);
builder.EmitReloc(factory.CopiedFieldRva(fieldDesc), RelocType.IMAGE_REL_BASED_ADDR32NB);
if (compressedFieldRef)
{
builder.EmitUShort((ushort)fieldToken);
}
else
{
builder.EmitUInt((uint)fieldToken);
}
}
}
public unsafe override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
BlobReader metadataBlob = new BlobReader(_sourceModule.PEReader.GetMetadata().Pointer, _sourceModule.PEReader.GetMetadata().Length);
var metadataReader = _sourceModule.MetadataReader;
//
// methodDef table
//
int methodDefTableOffset = metadataReader.GetTableMetadataOffset(TableIndex.MethodDef);
builder.EmitBytes(metadataBlob.ReadBytes(methodDefTableOffset));
WriteMethodTableRvas(factory, ref builder, ref metadataBlob);
//
// fieldRva table
//
int fieldRvaTableOffset = metadataReader.GetTableMetadataOffset(TableIndex.FieldRva);
builder.EmitBytes(metadataBlob.ReadBytes(fieldRvaTableOffset - metadataBlob.Offset));
WriteFieldRvas(factory, ref builder, ref metadataBlob);
// Copy the rest of the metadata blob
builder.EmitBytes(metadataBlob.ReadBytes(metadataReader.MetadataLength - metadataBlob.Offset));
Debug.Assert(builder.CountBytes == metadataBlob.Length);
Debug.Assert(builder.CountBytes == metadataBlob.Offset);
Debug.Assert(builder.CountBytes == Size);
return builder.ToObjectData();
}
protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);
public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
{
sb.Append(nameMangler.CompilationUnitPrefix);
sb.Append("__MetadataBlob");
}
public override int CompareToImpl(ISortableNode other, CompilerComparer comparer)
{
return _sourceModule.CompareTo(((CopiedMetadataBlobNode)other)._sourceModule);
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/CodeGenBringUpTests/AsgXor1.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
using System;
using System.Runtime.CompilerServices;
public class BringUpTest_AsgXor1
{
const int Pass = 100;
const int Fail = -1;
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static int AsgXor1(int x) { x ^= 0xf; return x; }
public static int Main()
{
if (AsgXor1(13) == 2) return Pass;
else return Fail;
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
using System;
using System.Runtime.CompilerServices;
public class BringUpTest_AsgXor1
{
const int Pass = 100;
const int Fail = -1;
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static int AsgXor1(int x) { x ^= 0xf; return x; }
public static int Main()
{
if (AsgXor1(13) == 2) return Pass;
else return Fail;
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/Regression/VS-ia64-JIT/V1.2-M01/b10790/b10790.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>PdbOnly</DebugType>
</PropertyGroup>
<ItemGroup>
<Compile Include="locals10K.cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>PdbOnly</DebugType>
</PropertyGroup>
<ItemGroup>
<Compile Include="locals10K.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/CngKey.Export.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Diagnostics;
using System.Runtime.InteropServices;
using Internal.Cryptography;
using Microsoft.Win32.SafeHandles;
using ErrorCode = Interop.NCrypt.ErrorCode;
namespace System.Security.Cryptography
{
/// <summary>
/// Managed representation of an NCrypt key
/// </summary>
public sealed partial class CngKey : IDisposable
{
/// <summary>
/// Export the key out of the KSP
/// </summary>
public byte[] Export(CngKeyBlobFormat format!!)
{
int numBytesNeeded;
ErrorCode errorCode = Interop.NCrypt.NCryptExportKey(_keyHandle, IntPtr.Zero, format.Format, IntPtr.Zero, null, 0, out numBytesNeeded, 0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
throw errorCode.ToCryptographicException();
byte[] buffer = new byte[numBytesNeeded];
errorCode = Interop.NCrypt.NCryptExportKey(_keyHandle, IntPtr.Zero, format.Format, IntPtr.Zero, buffer, buffer.Length, out numBytesNeeded, 0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
throw errorCode.ToCryptographicException();
Array.Resize(ref buffer, numBytesNeeded);
return buffer;
}
internal bool TryExportKeyBlob(
string blobType,
Span<byte> destination,
out int bytesWritten)
{
// Sanity check the current bounds
Span<byte> empty = default;
ErrorCode errorCode = Interop.NCrypt.NCryptExportKey(
_keyHandle,
IntPtr.Zero,
blobType,
IntPtr.Zero,
ref MemoryMarshal.GetReference(empty),
empty.Length,
out int written,
0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
{
throw errorCode.ToCryptographicException();
}
if (written > destination.Length)
{
bytesWritten = 0;
return false;
}
errorCode = Interop.NCrypt.NCryptExportKey(
_keyHandle,
IntPtr.Zero,
blobType,
IntPtr.Zero,
ref MemoryMarshal.GetReference(destination),
destination.Length,
out written,
0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
{
throw errorCode.ToCryptographicException();
}
bytesWritten = written;
return true;
}
internal byte[] ExportPkcs8KeyBlob(
ReadOnlySpan<char> password,
int kdfCount)
{
bool ret = ExportPkcs8KeyBlob(
allocate: true,
_keyHandle,
password,
kdfCount,
Span<byte>.Empty,
out _,
out byte[]? allocated);
Debug.Assert(ret);
Debug.Assert(allocated != null); // since `allocate: true`
return allocated;
}
internal bool TryExportPkcs8KeyBlob(
ReadOnlySpan<char> password,
int kdfCount,
Span<byte> destination,
out int bytesWritten)
{
return ExportPkcs8KeyBlob(
false,
_keyHandle,
password,
kdfCount,
destination,
out bytesWritten,
out _);
}
// The Windows APIs for OID strings are ASCII-only
private static readonly byte[] s_pkcs12TripleDesOidBytes =
System.Text.Encoding.ASCII.GetBytes("1.2.840.113549.1.12.1.3\0");
internal static unsafe bool ExportPkcs8KeyBlob(
bool allocate,
SafeNCryptKeyHandle keyHandle,
ReadOnlySpan<char> password,
int kdfCount,
Span<byte> destination,
out int bytesWritten,
out byte[]? allocated)
{
using (SafeUnicodeStringHandle stringHandle = new SafeUnicodeStringHandle(password))
{
fixed (byte* oidPtr = s_pkcs12TripleDesOidBytes)
{
Interop.NCrypt.NCryptBuffer* buffers = stackalloc Interop.NCrypt.NCryptBuffer[3];
Interop.NCrypt.PBE_PARAMS pbeParams = default;
Span<byte> salt = new Span<byte>(pbeParams.rgbSalt, Interop.NCrypt.PBE_PARAMS.RgbSaltSize);
RandomNumberGenerator.Fill(salt);
pbeParams.Params.cbSalt = salt.Length;
pbeParams.Params.iIterations = kdfCount;
buffers[0] = new Interop.NCrypt.NCryptBuffer
{
BufferType = Interop.NCrypt.BufferType.PkcsSecret,
cbBuffer = checked(2 * (password.Length + 1)),
pvBuffer = stringHandle.DangerousGetHandle(),
};
if (buffers[0].pvBuffer == IntPtr.Zero)
{
buffers[0].cbBuffer = 0;
}
buffers[1] = new Interop.NCrypt.NCryptBuffer
{
BufferType = Interop.NCrypt.BufferType.PkcsAlgOid,
cbBuffer = s_pkcs12TripleDesOidBytes.Length,
pvBuffer = (IntPtr)oidPtr,
};
buffers[2] = new Interop.NCrypt.NCryptBuffer
{
BufferType = Interop.NCrypt.BufferType.PkcsAlgParam,
cbBuffer = sizeof(Interop.NCrypt.PBE_PARAMS),
pvBuffer = (IntPtr)(&pbeParams),
};
Interop.NCrypt.NCryptBufferDesc desc = new Interop.NCrypt.NCryptBufferDesc
{
cBuffers = 3,
pBuffers = (IntPtr)buffers,
ulVersion = 0,
};
Span<byte> empty = default;
ErrorCode errorCode = Interop.NCrypt.NCryptExportKey(
keyHandle,
IntPtr.Zero,
Interop.NCrypt.NCRYPT_PKCS8_PRIVATE_KEY_BLOB,
ref desc,
ref MemoryMarshal.GetReference(empty),
0,
out int numBytesNeeded,
0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
{
throw errorCode.ToCryptographicException();
}
allocated = null;
if (allocate)
{
allocated = new byte[numBytesNeeded];
destination = allocated;
}
else if (numBytesNeeded > destination.Length)
{
bytesWritten = 0;
return false;
}
errorCode = Interop.NCrypt.NCryptExportKey(
keyHandle,
IntPtr.Zero,
Interop.NCrypt.NCRYPT_PKCS8_PRIVATE_KEY_BLOB,
ref desc,
ref MemoryMarshal.GetReference(destination),
destination.Length,
out numBytesNeeded,
0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
{
throw errorCode.ToCryptographicException();
}
if (allocate && numBytesNeeded != destination.Length)
{
byte[] trimmed = new byte[numBytesNeeded];
destination.Slice(0, numBytesNeeded).CopyTo(trimmed);
Array.Clear(allocated!, 0, numBytesNeeded);
allocated = trimmed;
}
bytesWritten = numBytesNeeded;
return true;
}
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Diagnostics;
using System.Runtime.InteropServices;
using Internal.Cryptography;
using Microsoft.Win32.SafeHandles;
using ErrorCode = Interop.NCrypt.ErrorCode;
namespace System.Security.Cryptography
{
/// <summary>
/// Managed representation of an NCrypt key
/// </summary>
public sealed partial class CngKey : IDisposable
{
/// <summary>
/// Export the key out of the KSP
/// </summary>
public byte[] Export(CngKeyBlobFormat format!!)
{
int numBytesNeeded;
ErrorCode errorCode = Interop.NCrypt.NCryptExportKey(_keyHandle, IntPtr.Zero, format.Format, IntPtr.Zero, null, 0, out numBytesNeeded, 0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
throw errorCode.ToCryptographicException();
byte[] buffer = new byte[numBytesNeeded];
errorCode = Interop.NCrypt.NCryptExportKey(_keyHandle, IntPtr.Zero, format.Format, IntPtr.Zero, buffer, buffer.Length, out numBytesNeeded, 0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
throw errorCode.ToCryptographicException();
Array.Resize(ref buffer, numBytesNeeded);
return buffer;
}
internal bool TryExportKeyBlob(
string blobType,
Span<byte> destination,
out int bytesWritten)
{
// Sanity check the current bounds
Span<byte> empty = default;
ErrorCode errorCode = Interop.NCrypt.NCryptExportKey(
_keyHandle,
IntPtr.Zero,
blobType,
IntPtr.Zero,
ref MemoryMarshal.GetReference(empty),
empty.Length,
out int written,
0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
{
throw errorCode.ToCryptographicException();
}
if (written > destination.Length)
{
bytesWritten = 0;
return false;
}
errorCode = Interop.NCrypt.NCryptExportKey(
_keyHandle,
IntPtr.Zero,
blobType,
IntPtr.Zero,
ref MemoryMarshal.GetReference(destination),
destination.Length,
out written,
0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
{
throw errorCode.ToCryptographicException();
}
bytesWritten = written;
return true;
}
internal byte[] ExportPkcs8KeyBlob(
ReadOnlySpan<char> password,
int kdfCount)
{
bool ret = ExportPkcs8KeyBlob(
allocate: true,
_keyHandle,
password,
kdfCount,
Span<byte>.Empty,
out _,
out byte[]? allocated);
Debug.Assert(ret);
Debug.Assert(allocated != null); // since `allocate: true`
return allocated;
}
internal bool TryExportPkcs8KeyBlob(
ReadOnlySpan<char> password,
int kdfCount,
Span<byte> destination,
out int bytesWritten)
{
return ExportPkcs8KeyBlob(
false,
_keyHandle,
password,
kdfCount,
destination,
out bytesWritten,
out _);
}
// The Windows APIs for OID strings are ASCII-only
private static readonly byte[] s_pkcs12TripleDesOidBytes =
System.Text.Encoding.ASCII.GetBytes("1.2.840.113549.1.12.1.3\0");
internal static unsafe bool ExportPkcs8KeyBlob(
bool allocate,
SafeNCryptKeyHandle keyHandle,
ReadOnlySpan<char> password,
int kdfCount,
Span<byte> destination,
out int bytesWritten,
out byte[]? allocated)
{
using (SafeUnicodeStringHandle stringHandle = new SafeUnicodeStringHandle(password))
{
fixed (byte* oidPtr = s_pkcs12TripleDesOidBytes)
{
Interop.NCrypt.NCryptBuffer* buffers = stackalloc Interop.NCrypt.NCryptBuffer[3];
Interop.NCrypt.PBE_PARAMS pbeParams = default;
Span<byte> salt = new Span<byte>(pbeParams.rgbSalt, Interop.NCrypt.PBE_PARAMS.RgbSaltSize);
RandomNumberGenerator.Fill(salt);
pbeParams.Params.cbSalt = salt.Length;
pbeParams.Params.iIterations = kdfCount;
buffers[0] = new Interop.NCrypt.NCryptBuffer
{
BufferType = Interop.NCrypt.BufferType.PkcsSecret,
cbBuffer = checked(2 * (password.Length + 1)),
pvBuffer = stringHandle.DangerousGetHandle(),
};
if (buffers[0].pvBuffer == IntPtr.Zero)
{
buffers[0].cbBuffer = 0;
}
buffers[1] = new Interop.NCrypt.NCryptBuffer
{
BufferType = Interop.NCrypt.BufferType.PkcsAlgOid,
cbBuffer = s_pkcs12TripleDesOidBytes.Length,
pvBuffer = (IntPtr)oidPtr,
};
buffers[2] = new Interop.NCrypt.NCryptBuffer
{
BufferType = Interop.NCrypt.BufferType.PkcsAlgParam,
cbBuffer = sizeof(Interop.NCrypt.PBE_PARAMS),
pvBuffer = (IntPtr)(&pbeParams),
};
Interop.NCrypt.NCryptBufferDesc desc = new Interop.NCrypt.NCryptBufferDesc
{
cBuffers = 3,
pBuffers = (IntPtr)buffers,
ulVersion = 0,
};
Span<byte> empty = default;
ErrorCode errorCode = Interop.NCrypt.NCryptExportKey(
keyHandle,
IntPtr.Zero,
Interop.NCrypt.NCRYPT_PKCS8_PRIVATE_KEY_BLOB,
ref desc,
ref MemoryMarshal.GetReference(empty),
0,
out int numBytesNeeded,
0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
{
throw errorCode.ToCryptographicException();
}
allocated = null;
if (allocate)
{
allocated = new byte[numBytesNeeded];
destination = allocated;
}
else if (numBytesNeeded > destination.Length)
{
bytesWritten = 0;
return false;
}
errorCode = Interop.NCrypt.NCryptExportKey(
keyHandle,
IntPtr.Zero,
Interop.NCrypt.NCRYPT_PKCS8_PRIVATE_KEY_BLOB,
ref desc,
ref MemoryMarshal.GetReference(destination),
destination.Length,
out numBytesNeeded,
0);
if (errorCode != ErrorCode.ERROR_SUCCESS)
{
throw errorCode.ToCryptographicException();
}
if (allocate && numBytesNeeded != destination.Length)
{
byte[] trimmed = new byte[numBytesNeeded];
destination.Slice(0, numBytesNeeded).CopyTo(trimmed);
Array.Clear(allocated!, 0, numBytesNeeded);
allocated = trimmed;
}
bytesWritten = numBytesNeeded;
return true;
}
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/Common/src/Interop/Windows/SspiCli/Interop.SECURITY_LOGON_SESSION_DATA.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Runtime.InteropServices;
internal static partial class Interop
{
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
internal struct SECURITY_LOGON_SESSION_DATA
{
internal uint Size;
internal LUID LogonId;
internal UNICODE_INTPTR_STRING UserName;
internal UNICODE_INTPTR_STRING LogonDomain;
internal UNICODE_INTPTR_STRING AuthenticationPackage;
internal uint LogonType;
internal uint Session;
internal IntPtr Sid;
internal long LogonTime;
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Runtime.InteropServices;
internal static partial class Interop
{
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
internal struct SECURITY_LOGON_SESSION_DATA
{
internal uint Size;
internal LUID LogonId;
internal UNICODE_INTPTR_STRING UserName;
internal UNICODE_INTPTR_STRING LogonDomain;
internal UNICODE_INTPTR_STRING AuthenticationPackage;
internal uint LogonType;
internal uint Session;
internal IntPtr Sid;
internal long LogonTime;
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Runtime.Loader/tests/ApplyUpdate/System.Reflection.Metadata.ApplyUpdate.Test.AddStaticLambda/AddStaticLambda_v1.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
namespace System.Reflection.Metadata.ApplyUpdate.Test
{
public class AddStaticLambda
{
public string TestMethod()
{
return Double(static (s) => s + "abcd");
}
public string Double(Func<string,string> f) => f("") + f("1");
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
namespace System.Reflection.Metadata.ApplyUpdate.Test
{
public class AddStaticLambda
{
public string TestMethod()
{
return Double(static (s) => s + "abcd");
}
public string Double(Func<string,string> f) => f("") + f("1");
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/GC/API/WeakReference/TrackResurrection.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// Tests WeakReference.TrackResurrection
// Retrieves a boolean indicating whether objects are tracked.
// TRUE: The reference will refer to the target until it is reclaimed by the Runtime
// (until collection).
// FALSE: The reference will refer to the target until the first time it is detected
// to be unreachable by Runtime (until Finalization).
using System;
public class Test_TrackResurrection {
public static int Main() {
int[] array = new int[50];
Object obj = new Object();
WeakReference weak1 = new WeakReference(array,true);
WeakReference weak2 = new WeakReference(obj,false);
bool ans1 = weak1.TrackResurrection;
bool ans2 = weak2.TrackResurrection;
if((ans1 == true) && (ans2 == false)) {
Console.WriteLine("Test for WeakReference.TrackResurrection passed!");
return 100;
}
else {
Console.WriteLine("Test for WeakReference.TrackResurrection failed!");
return 1;
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// Tests WeakReference.TrackResurrection
// Retrieves a boolean indicating whether objects are tracked.
// TRUE: The reference will refer to the target until it is reclaimed by the Runtime
// (until collection).
// FALSE: The reference will refer to the target until the first time it is detected
// to be unreachable by Runtime (until Finalization).
using System;
public class Test_TrackResurrection {
public static int Main() {
int[] array = new int[50];
Object obj = new Object();
WeakReference weak1 = new WeakReference(array,true);
WeakReference weak2 = new WeakReference(obj,false);
bool ans1 = weak1.TrackResurrection;
bool ans2 = weak2.TrackResurrection;
if((ans1 == true) && (ans2 == false)) {
Console.WriteLine("Test for WeakReference.TrackResurrection passed!");
return 100;
}
else {
Console.WriteLine("Test for WeakReference.TrackResurrection failed!");
return 1;
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/Methodical/Boxing/morph/sin_cs_r.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<!-- Set to 'Full' if the Debug? column is marked in the spreadsheet. Leave blank otherwise. -->
<DebugType>None</DebugType>
<Optimize>False</Optimize>
<NoStandardLib>True</NoStandardLib>
<Noconfig>True</Noconfig>
</PropertyGroup>
<ItemGroup>
<Compile Include="sin.cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<!-- Set to 'Full' if the Debug? column is marked in the spreadsheet. Leave blank otherwise. -->
<DebugType>None</DebugType>
<Optimize>False</Optimize>
<NoStandardLib>True</NoStandardLib>
<Noconfig>True</Noconfig>
</PropertyGroup>
<ItemGroup>
<Compile Include="sin.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeBuilderState.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Text;
using Internal.Runtime;
using Internal.Runtime.Augments;
using Internal.Runtime.CompilerServices;
using Internal.Metadata.NativeFormat;
using Internal.NativeFormat;
using Internal.TypeSystem;
using Internal.TypeSystem.NativeFormat;
using Internal.TypeSystem.NoMetadata;
namespace Internal.Runtime.TypeLoader
{
internal struct NativeLayoutInfo
{
public uint Offset;
public NativeFormatModuleInfo Module;
public NativeReader Reader;
public NativeLayoutInfoLoadContext LoadContext;
}
//
// TypeBuilder per-Type state. It is attached to each TypeDesc that gets involved in type building.
//
internal class TypeBuilderState
{
internal class VTableLayoutInfo
{
public uint VTableSlot;
public RuntimeSignature MethodSignature;
public bool IsSealedVTableSlot;
}
internal class VTableSlotMapper
{
private int[] _slotMap;
private IntPtr[] _dictionarySlots;
private int _numMappingsAssigned;
public VTableSlotMapper(int numVtableSlotsInTemplateType)
{
_slotMap = new int[numVtableSlotsInTemplateType];
_dictionarySlots = new IntPtr[numVtableSlotsInTemplateType];
_numMappingsAssigned = 0;
for (int i = 0; i < numVtableSlotsInTemplateType; i++)
{
_slotMap[i] = -1;
_dictionarySlots[i] = IntPtr.Zero;
}
}
public void AddMapping(int vtableSlotInTemplateType, int vtableSlotInTargetType, IntPtr dictionaryValueInSlot)
{
Debug.Assert(_numMappingsAssigned < _slotMap.Length);
_slotMap[vtableSlotInTemplateType] = vtableSlotInTargetType;
_dictionarySlots[vtableSlotInTemplateType] = dictionaryValueInSlot;
_numMappingsAssigned++;
}
public int GetVTableSlotInTargetType(int vtableSlotInTemplateType)
{
Debug.Assert((uint)vtableSlotInTemplateType < (uint)_slotMap.Length);
return _slotMap[vtableSlotInTemplateType];
}
public bool IsDictionarySlot(int vtableSlotInTemplateType, out IntPtr dictionaryPtrValue)
{
Debug.Assert((uint)vtableSlotInTemplateType < (uint)_dictionarySlots.Length);
dictionaryPtrValue = _dictionarySlots[vtableSlotInTemplateType];
return _dictionarySlots[vtableSlotInTemplateType] != IntPtr.Zero;
}
public int NumSlotMappings
{
get { return _numMappingsAssigned; }
}
}
public TypeBuilderState(TypeDesc typeBeingBuilt)
{
TypeBeingBuilt = typeBeingBuilt;
}
public readonly TypeDesc TypeBeingBuilt;
//
// We cache and try to reuse the most recently used TypeSystemContext. The TypeSystemContext is used by not just type builder itself,
// but also in several random other places in reflection. There can be multiple ResolutionContexts in flight at any given moment.
// This check ensures that the RuntimeTypeHandle cache in the current resolution context is refreshed in case there were new
// types built using a different TypeSystemContext in the meantime.
// NOTE: For correctness, this value must be recomputed every time the context is recycled. This requires flushing the TypeBuilderState
// from each type that has one if context is recycled.
//
public bool AttemptedAndFailedToRetrieveTypeHandle;
public bool NeedsTypeHandle;
public bool HasBeenPrepared;
public RuntimeTypeHandle HalfBakedRuntimeTypeHandle;
public IntPtr HalfBakedDictionary;
public IntPtr HalfBakedSealedVTable;
private bool _templateComputed;
private bool _nativeLayoutTokenComputed;
private TypeDesc _templateType;
public TypeDesc TemplateType
{
get
{
if (!_templateComputed)
{
// Multidimensional arrays and szarrays of pointers don't implement generic interfaces and are special cases. They use
// typeof(object[,]) as their template.
if (TypeBeingBuilt.IsMdArray || (TypeBeingBuilt.IsSzArray && ((ArrayType)TypeBeingBuilt).ElementType.IsPointer))
{
_templateType = TypeBeingBuilt.Context.ResolveRuntimeTypeHandle(typeof(object[,]).TypeHandle);
_templateTypeLoaderNativeLayout = false;
_nativeLayoutComputed = _nativeLayoutTokenComputed = _templateComputed = true;
return _templateType;
}
// Locate the template type and native layout info
_templateType = TypeBeingBuilt.Context.TemplateLookup.TryGetTypeTemplate(TypeBeingBuilt, ref _nativeLayoutInfo);
Debug.Assert(_templateType == null || !_templateType.RuntimeTypeHandle.IsNull());
_templateTypeLoaderNativeLayout = true;
_templateComputed = true;
if ((_templateType != null) && !_templateType.IsCanonicalSubtype(CanonicalFormKind.Universal))
_nativeLayoutTokenComputed = true;
}
return _templateType;
}
}
private bool _nativeLayoutComputed;
private bool _templateTypeLoaderNativeLayout;
private bool _readyToRunNativeLayout;
private NativeLayoutInfo _nativeLayoutInfo;
private NativeLayoutInfo _r2rnativeLayoutInfo;
private void EnsureNativeLayoutInfoComputed()
{
if (!_nativeLayoutComputed)
{
if (!_nativeLayoutTokenComputed)
{
if (!_templateComputed)
{
// Attempt to compute native layout through as a non-ReadyToRun template
object _ = this.TemplateType;
}
if (!_nativeLayoutTokenComputed)
{
TypeBeingBuilt.Context.TemplateLookup.TryGetMetadataNativeLayout(TypeBeingBuilt, out _r2rnativeLayoutInfo.Module, out _r2rnativeLayoutInfo.Offset);
if (_r2rnativeLayoutInfo.Module != null)
_readyToRunNativeLayout = true;
}
_nativeLayoutTokenComputed = true;
}
if (_nativeLayoutInfo.Module != null)
{
FinishInitNativeLayoutInfo(TypeBeingBuilt, ref _nativeLayoutInfo);
}
if (_r2rnativeLayoutInfo.Module != null)
{
FinishInitNativeLayoutInfo(TypeBeingBuilt, ref _r2rnativeLayoutInfo);
}
_nativeLayoutComputed = true;
}
}
/// <summary>
/// Initialize the Reader and LoadContext fields of the native layout info
/// </summary>
/// <param name="type"></param>
/// <param name="nativeLayoutInfo"></param>
private static void FinishInitNativeLayoutInfo(TypeDesc type, ref NativeLayoutInfo nativeLayoutInfo)
{
var nativeLayoutInfoLoadContext = new NativeLayoutInfoLoadContext();
nativeLayoutInfoLoadContext._typeSystemContext = type.Context;
nativeLayoutInfoLoadContext._module = nativeLayoutInfo.Module;
if (type is DefType)
{
nativeLayoutInfoLoadContext._typeArgumentHandles = ((DefType)type).Instantiation;
}
else if (type is ArrayType)
{
nativeLayoutInfoLoadContext._typeArgumentHandles = new Instantiation(new TypeDesc[] { ((ArrayType)type).ElementType });
}
else
{
Debug.Assert(false);
}
nativeLayoutInfoLoadContext._methodArgumentHandles = new Instantiation(null);
nativeLayoutInfo.Reader = TypeLoaderEnvironment.Instance.GetNativeLayoutInfoReader(nativeLayoutInfo.Module.Handle);
nativeLayoutInfo.LoadContext = nativeLayoutInfoLoadContext;
}
public NativeLayoutInfo NativeLayoutInfo
{
get
{
EnsureNativeLayoutInfoComputed();
return _nativeLayoutInfo;
}
}
public NativeLayoutInfo R2RNativeLayoutInfo
{
get
{
EnsureNativeLayoutInfoComputed();
return _r2rnativeLayoutInfo;
}
}
public NativeParser GetParserForNativeLayoutInfo()
{
EnsureNativeLayoutInfoComputed();
if (_templateTypeLoaderNativeLayout)
return new NativeParser(_nativeLayoutInfo.Reader, _nativeLayoutInfo.Offset);
else
return default(NativeParser);
}
public NativeParser GetParserForReadyToRunNativeLayoutInfo()
{
EnsureNativeLayoutInfoComputed();
if (_readyToRunNativeLayout)
return new NativeParser(_r2rnativeLayoutInfo.Reader, _r2rnativeLayoutInfo.Offset);
else
return default(NativeParser);
}
public NativeParser GetParserForUniversalNativeLayoutInfo(out NativeLayoutInfoLoadContext universalLayoutLoadContext, out NativeLayoutInfo universalLayoutInfo)
{
universalLayoutInfo = new NativeLayoutInfo();
universalLayoutLoadContext = null;
TypeDesc universalTemplate = TypeBeingBuilt.Context.TemplateLookup.TryGetUniversalTypeTemplate(TypeBeingBuilt, ref universalLayoutInfo);
if (universalTemplate == null)
return new NativeParser();
FinishInitNativeLayoutInfo(TypeBeingBuilt, ref universalLayoutInfo);
universalLayoutLoadContext = universalLayoutInfo.LoadContext;
return new NativeParser(universalLayoutInfo.Reader, universalLayoutInfo.Offset);
}
// RuntimeInterfaces is the full list of interfaces that the type implements. It can include private internal implementation
// detail interfaces that nothing is known about.
public DefType[] RuntimeInterfaces
{
get
{
// Generic Type Definitions have no runtime interfaces
if (TypeBeingBuilt.IsGenericDefinition)
return null;
return TypeBeingBuilt.RuntimeInterfaces;
}
}
private bool? _hasDictionarySlotInVTable;
private bool ComputeHasDictionarySlotInVTable()
{
if (!TypeBeingBuilt.IsGeneric() && !(TypeBeingBuilt is ArrayType))
return false;
// Generic interfaces always have a dictionary slot
if (TypeBeingBuilt.IsInterface)
return true;
return TypeBeingBuilt.CanShareNormalGenericCode();
}
public bool HasDictionarySlotInVTable
{
get
{
if (_hasDictionarySlotInVTable == null)
{
_hasDictionarySlotInVTable = ComputeHasDictionarySlotInVTable();
}
return _hasDictionarySlotInVTable.Value;
}
}
private bool? _hasDictionaryInVTable;
private bool ComputeHasDictionaryInVTable()
{
if (!HasDictionarySlotInVTable)
return false;
if (TypeBeingBuilt.RetrieveRuntimeTypeHandleIfPossible())
{
// Type was already constructed
return TypeBeingBuilt.RuntimeTypeHandle.GetDictionary() != IntPtr.Zero;
}
else
{
// Type is being newly constructed
if (TemplateType != null)
{
NativeParser parser = GetParserForNativeLayoutInfo();
// Template type loader case
#if GENERICS_FORCE_USG
bool isTemplateUniversalCanon = state.TemplateType.IsCanonicalSubtype(CanonicalFormKind.UniversalCanonLookup);
if (isTemplateUniversalCanon && type.CanShareNormalGenericCode())
{
TypeBuilderState tempState = new TypeBuilderState();
tempState.NativeLayoutInfo = new NativeLayoutInfo();
tempState.TemplateType = type.Context.TemplateLookup.TryGetNonUniversalTypeTemplate(type, ref tempState.NativeLayoutInfo);
if (tempState.TemplateType != null)
{
Debug.Assert(!tempState.TemplateType.IsCanonicalSubtype(CanonicalFormKind.UniversalCanonLookup));
parser = GetNativeLayoutInfoParser(type, ref tempState.NativeLayoutInfo);
}
}
#endif
var dictionaryLayoutParser = parser.GetParserForBagElementKind(BagElementKind.DictionaryLayout);
return !dictionaryLayoutParser.IsNull;
}
else
{
NativeParser parser = GetParserForReadyToRunNativeLayoutInfo();
// ReadyToRun case
// Dictionary is directly encoded instead of the NativeLayout being a collection of bags
if (parser.IsNull)
return false;
// First unsigned value in the native layout is the number of dictionary entries
return parser.GetUnsigned() != 0;
}
}
}
public bool HasDictionaryInVTable
{
get
{
if (_hasDictionaryInVTable == null)
_hasDictionaryInVTable = ComputeHasDictionaryInVTable();
return _hasDictionaryInVTable.Value;
}
}
private ushort? _numVTableSlots;
private ushort ComputeNumVTableSlots()
{
if (TypeBeingBuilt.RetrieveRuntimeTypeHandleIfPossible())
{
unsafe
{
return TypeBeingBuilt.RuntimeTypeHandle.ToEETypePtr()->NumVtableSlots;
}
}
else
{
TypeDesc templateType = TypeBeingBuilt.ComputeTemplate(false);
if (templateType != null)
{
// Template type loader case
if (VTableSlotsMapping != null)
{
return checked((ushort)VTableSlotsMapping.NumSlotMappings);
}
else
{
unsafe
{
if (TypeBeingBuilt.IsMdArray || (TypeBeingBuilt.IsSzArray && ((ArrayType)TypeBeingBuilt).ElementType.IsPointer))
{
// MDArray types and pointer arrays have the same vtable as the System.Array type they "derive" from.
// They do not implement the generic interfaces that make this interesting for normal arrays.
return TypeBeingBuilt.BaseType.GetRuntimeTypeHandle().ToEETypePtr()->NumVtableSlots;
}
else
{
// This should only happen for non-universal templates
Debug.Assert(TypeBeingBuilt.IsTemplateCanonical());
// Canonical template type loader case
return templateType.GetRuntimeTypeHandle().ToEETypePtr()->NumVtableSlots;
}
}
}
}
else
{
// Metadata based type loading.
// Generic Type Definitions have no actual vtable entries
if (TypeBeingBuilt.IsGenericDefinition)
return 0;
// We have at least as many slots as exist on the base type.
ushort numVTableSlots = 0;
checked
{
if (TypeBeingBuilt.BaseType != null)
{
numVTableSlots = TypeBeingBuilt.BaseType.GetOrCreateTypeBuilderState().NumVTableSlots;
}
else
{
// Generic interfaces have a dictionary slot
if (TypeBeingBuilt.IsInterface && TypeBeingBuilt.HasInstantiation)
numVTableSlots = 1;
}
// Interfaces have actual vtable slots
if (TypeBeingBuilt.IsInterface)
return numVTableSlots;
foreach (MethodDesc method in TypeBeingBuilt.GetMethods())
{
#if SUPPORTS_NATIVE_METADATA_TYPE_LOADING
if (LazyVTableResolver.MethodDefinesVTableSlot(method))
numVTableSlots++;
#else
Environment.FailFast("metadata type loader required");
#endif
}
if (HasDictionarySlotInVTable)
numVTableSlots++;
}
return numVTableSlots;
}
}
}
public ushort NumVTableSlots
{
get
{
if (_numVTableSlots == null)
_numVTableSlots = ComputeNumVTableSlots();
return _numVTableSlots.Value;
}
}
public GenericTypeDictionary Dictionary;
public int NonGcDataSize
{
get
{
DefType defType = TypeBeingBuilt as DefType;
// The NonGCStatic fields hold the class constructor data if it exists in the negative space
// of the memory region. The ClassConstructorOffset is negative, so it must be negated to
// determine the extra space that is used.
if (defType != null)
{
return defType.NonGCStaticFieldSize.AsInt - (HasStaticConstructor ? TypeBuilder.ClassConstructorOffset : 0);
}
else
{
return -(HasStaticConstructor ? TypeBuilder.ClassConstructorOffset : 0);
}
}
}
public int GcDataSize
{
get
{
DefType defType = TypeBeingBuilt as DefType;
if (defType != null)
{
return defType.GCStaticFieldSize.AsInt;
}
else
{
return 0;
}
}
}
public int ThreadDataSize
{
get
{
DefType defType = TypeBeingBuilt as DefType;
if (defType != null && !defType.IsGenericDefinition)
{
return defType.ThreadGcStaticFieldSize.AsInt;
}
else
{
// Non-DefType's and GenericEETypeDefinitions do not have static fields of any form
return 0;
}
}
}
public bool HasStaticConstructor
{
get { return TypeBeingBuilt.HasStaticConstructor; }
}
public IntPtr? ClassConstructorPointer;
public IntPtr GcStaticDesc;
public IntPtr GcStaticEEType;
public IntPtr ThreadStaticDesc;
public bool AllocatedStaticGCDesc;
public bool AllocatedThreadStaticGCDesc;
public uint ThreadStaticOffset;
public uint NumSealedVTableEntries;
public GenericVariance[] GenericVarianceFlags;
// Sentinel static to allow us to initialize _instanceLayout to something
// and then detect that InstanceGCLayout should return null
private static LowLevelList<bool> s_emptyLayout = new LowLevelList<bool>();
private LowLevelList<bool> _instanceGCLayout;
/// <summary>
/// The instance gc layout of a dynamically laid out type.
/// null if one of the following is true
/// 1) For an array type:
/// - the type is a reference array
/// 2) For a generic type:
/// - the type has no GC instance fields
/// - the type already has a type handle
/// - the type has a non-universal canonical template
/// - the type has already been constructed
///
/// If the type is a valuetype array, this is the layout of the valuetype held in the array if the type has GC reference fields
/// Otherwise, it is the layout of the fields in the type.
/// </summary>
public LowLevelList<bool> InstanceGCLayout
{
get
{
if (_instanceGCLayout == null)
{
LowLevelList<bool> instanceGCLayout = null;
if (TypeBeingBuilt is ArrayType)
{
if (!IsArrayOfReferenceTypes)
{
ArrayType arrayType = (ArrayType)TypeBeingBuilt;
TypeBuilder.GCLayout elementGcLayout = GetFieldGCLayout(arrayType.ElementType);
if (!elementGcLayout.IsNone)
{
instanceGCLayout = new LowLevelList<bool>();
elementGcLayout.WriteToBitfield(instanceGCLayout, 0);
_instanceGCLayout = instanceGCLayout;
}
}
else
{
// Array of reference type returns null
_instanceGCLayout = s_emptyLayout;
}
}
else if (TypeBeingBuilt.RetrieveRuntimeTypeHandleIfPossible() ||
TypeBeingBuilt.IsTemplateCanonical() ||
(TypeBeingBuilt is PointerType) ||
(TypeBeingBuilt is ByRefType))
{
_instanceGCLayout = s_emptyLayout;
}
else
{
// Generic Type Definitions have no gc layout
if (!(TypeBeingBuilt.IsGenericDefinition))
{
// Copy in from base type
if (!TypeBeingBuilt.IsValueType && (TypeBeingBuilt.BaseType != null))
{
DefType baseType = TypeBeingBuilt.BaseType;
// Capture the gc layout from the base type
TypeBuilder.GCLayout baseTypeLayout = GetInstanceGCLayout(baseType);
if (!baseTypeLayout.IsNone)
{
instanceGCLayout = new LowLevelList<bool>();
baseTypeLayout.WriteToBitfield(instanceGCLayout, IntPtr.Size /* account for the MethodTable pointer */);
}
}
foreach (FieldDesc field in GetFieldsForGCLayout())
{
if (field.IsStatic)
continue;
if (field.IsLiteral)
continue;
TypeBuilder.GCLayout fieldGcLayout = GetFieldGCLayout(field.FieldType);
if (!fieldGcLayout.IsNone)
{
if (instanceGCLayout == null)
instanceGCLayout = new LowLevelList<bool>();
fieldGcLayout.WriteToBitfield(instanceGCLayout, field.Offset.AsInt);
}
}
if ((instanceGCLayout != null) && instanceGCLayout.HasSetBits())
{
// When bits are set in the instance GC layout, it implies that the type contains GC refs,
// which implies that the type size is pointer-aligned. In this case consumers assume that
// the type size can be computed by multiplying the bitfield size by the pointer size. If
// necessary, expand the bitfield to ensure that this invariant holds.
// Valuetypes with gc fields must be aligned on at least pointer boundaries
Debug.Assert(!TypeBeingBuilt.IsValueType || (FieldAlignment.Value >= TypeBeingBuilt.Context.Target.PointerSize));
// Valuetypes with gc fields must have a type size which is aligned on an IntPtr boundary.
Debug.Assert(!TypeBeingBuilt.IsValueType || ((TypeSize.Value & (IntPtr.Size - 1)) == 0));
int impliedBitCount = (TypeSize.Value + IntPtr.Size - 1) / IntPtr.Size;
Debug.Assert(instanceGCLayout.Count <= impliedBitCount);
instanceGCLayout.Expand(impliedBitCount);
Debug.Assert(instanceGCLayout.Count == impliedBitCount);
}
}
if (instanceGCLayout == null)
_instanceGCLayout = s_emptyLayout;
else
_instanceGCLayout = instanceGCLayout;
}
}
if (_instanceGCLayout == s_emptyLayout)
return null;
else
return _instanceGCLayout;
}
}
public LowLevelList<bool> StaticGCLayout;
public LowLevelList<bool> ThreadStaticGCLayout;
private bool _staticGCLayoutPrepared;
/// <summary>
/// Prepare the StaticGCLayout/ThreadStaticGCLayout/GcStaticDesc/ThreadStaticDesc fields by
/// reading native layout or metadata as appropriate. This method should only be called for types which
/// are actually to be created.
/// </summary>
public void PrepareStaticGCLayout()
{
if (!_staticGCLayoutPrepared)
{
_staticGCLayoutPrepared = true;
DefType defType = TypeBeingBuilt as DefType;
if (defType == null)
{
// Array/pointer types do not have static fields
}
else if (defType.IsTemplateCanonical())
{
// Canonical templates get their layout directly from the NativeLayoutInfo.
// Parse it and pull that info out here.
NativeParser typeInfoParser = GetParserForNativeLayoutInfo();
BagElementKind kind;
while ((kind = typeInfoParser.GetBagElementKind()) != BagElementKind.End)
{
switch (kind)
{
case BagElementKind.GcStaticDesc:
GcStaticDesc = NativeLayoutInfo.LoadContext.GetGCStaticInfo(typeInfoParser.GetUnsigned());
break;
case BagElementKind.ThreadStaticDesc:
ThreadStaticDesc = NativeLayoutInfo.LoadContext.GetGCStaticInfo(typeInfoParser.GetUnsigned());
break;
case BagElementKind.GcStaticEEType:
GcStaticEEType = NativeLayoutInfo.LoadContext.GetGCStaticInfo(typeInfoParser.GetUnsigned());
break;
default:
typeInfoParser.SkipInteger();
break;
}
}
}
else
{
// Compute GC layout boolean array from field information.
IEnumerable<FieldDesc> fields = GetFieldsForGCLayout();
LowLevelList<bool> threadStaticLayout = null;
LowLevelList<bool> gcStaticLayout = null;
foreach (FieldDesc field in fields)
{
if (!field.IsStatic)
continue;
if (field.IsLiteral)
continue;
LowLevelList<bool> gcLayoutInfo = null;
if (field.IsThreadStatic)
{
if (threadStaticLayout == null)
threadStaticLayout = new LowLevelList<bool>();
gcLayoutInfo = threadStaticLayout;
}
else if (field.HasGCStaticBase)
{
if (gcStaticLayout == null)
gcStaticLayout = new LowLevelList<bool>();
gcLayoutInfo = gcStaticLayout;
}
else
{
// Non-GC static no need to record information
continue;
}
TypeBuilder.GCLayout fieldGcLayout = GetFieldGCLayout(field.FieldType);
fieldGcLayout.WriteToBitfield(gcLayoutInfo, field.Offset.AsInt);
}
if (gcStaticLayout != null && gcStaticLayout.Count > 0)
StaticGCLayout = gcStaticLayout;
if (threadStaticLayout != null && threadStaticLayout.Count > 0)
ThreadStaticGCLayout = threadStaticLayout;
}
}
}
/// <summary>
/// Get an enumerable list of the fields used for dynamic gc layout calculation.
/// </summary>
private IEnumerable<FieldDesc> GetFieldsForGCLayout()
{
DefType defType = (DefType)TypeBeingBuilt;
IEnumerable<FieldDesc> fields;
if (defType.ComputeTemplate(false) != null)
{
// we have native layout and a template. Use the NativeLayoutFields as that is the only complete
// description of the fields available. (There may be metadata fields, but those aren't guaranteed
// to be a complete set of fields due to reflection reduction.
NativeLayoutFieldAlgorithm.EnsureFieldLayoutLoadedForGenericType(defType);
fields = defType.NativeLayoutFields;
}
else
{
// The metadata case. We're loading the type from regular metadata, so use the regular metadata fields
fields = defType.GetFields();
}
return fields;
}
// Get the GC layout of a type. Handles pre-created, universal template, and non-universal template cases
// Only to be used for getting the instance layout of non-valuetypes.
/// <summary>
/// Get the GC layout of a type. Handles pre-created, universal template, and non-universal template cases
/// Only to be used for getting the instance layout of non-valuetypes that are used as base types
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private unsafe TypeBuilder.GCLayout GetInstanceGCLayout(TypeDesc type)
{
Debug.Assert(!type.IsCanonicalSubtype(CanonicalFormKind.Any));
Debug.Assert(!type.IsValueType);
if (type.RetrieveRuntimeTypeHandleIfPossible())
{
return new TypeBuilder.GCLayout(type.RuntimeTypeHandle);
}
if (type.IsTemplateCanonical())
{
var templateType = type.ComputeTemplate();
bool success = templateType.RetrieveRuntimeTypeHandleIfPossible();
Debug.Assert(success && !templateType.RuntimeTypeHandle.IsNull());
return new TypeBuilder.GCLayout(templateType.RuntimeTypeHandle);
}
else
{
TypeBuilderState state = type.GetOrCreateTypeBuilderState();
if (state.InstanceGCLayout == null)
return TypeBuilder.GCLayout.None;
else
return new TypeBuilder.GCLayout(state.InstanceGCLayout, true);
}
}
/// <summary>
/// Get the GC layout of a type when used as a field.
/// NOTE: if the fieldtype is a reference type, this function will return GCLayout.None
/// Consumers of the api must handle that special case.
/// </summary>
private unsafe TypeBuilder.GCLayout GetFieldGCLayout(TypeDesc fieldType)
{
if (!fieldType.IsValueType)
{
if (fieldType.IsPointer)
return TypeBuilder.GCLayout.None;
else
return TypeBuilder.GCLayout.SingleReference;
}
// Is this a type that already exists? If so, get its gclayout from the MethodTable directly
if (fieldType.RetrieveRuntimeTypeHandleIfPossible())
{
return new TypeBuilder.GCLayout(fieldType.RuntimeTypeHandle);
}
// The type of the field must be a valuetype that is dynamically being constructed
if (fieldType.IsTemplateCanonical())
{
// Pull the GC Desc from the canonical instantiation
TypeDesc templateType = fieldType.ComputeTemplate();
bool success = templateType.RetrieveRuntimeTypeHandleIfPossible();
Debug.Assert(success);
return new TypeBuilder.GCLayout(templateType.RuntimeTypeHandle);
}
else
{
// Use the type builder state's computed InstanceGCLayout
var instanceGCLayout = fieldType.GetOrCreateTypeBuilderState().InstanceGCLayout;
if (instanceGCLayout == null)
return TypeBuilder.GCLayout.None;
return new TypeBuilder.GCLayout(instanceGCLayout, false /* Always represents a valuetype as the reference type case
is handled above with the GCLayout.SingleReference return */);
}
}
public bool IsArrayOfReferenceTypes
{
get
{
ArrayType typeAsArrayType = TypeBeingBuilt as ArrayType;
if (typeAsArrayType != null)
return !typeAsArrayType.ParameterType.IsValueType && !typeAsArrayType.ParameterType.IsPointer;
else
return false;
}
}
// Rank for arrays, -1 is used for an SzArray, and a positive number for a multidimensional array.
public int? ArrayRank
{
get
{
if (!TypeBeingBuilt.IsArray)
return null;
else if (TypeBeingBuilt.IsSzArray)
return -1;
else
{
Debug.Assert(TypeBeingBuilt.IsMdArray);
return ((ArrayType)TypeBeingBuilt).Rank;
}
}
}
public int? BaseTypeSize
{
get
{
if (TypeBeingBuilt.BaseType == null)
{
return null;
}
else
{
return TypeBeingBuilt.BaseType.InstanceByteCountUnaligned.AsInt;
}
}
}
public int? TypeSize
{
get
{
DefType defType = TypeBeingBuilt as DefType;
if (defType != null)
{
// Generic Type Definition EETypes do not have size
if (defType.IsGenericDefinition)
return null;
if (defType.IsValueType)
{
return defType.InstanceFieldSize.AsInt;
}
else
{
if (defType.IsInterface)
return IntPtr.Size;
return defType.InstanceByteCountUnaligned.AsInt;
}
}
else if (TypeBeingBuilt is ArrayType)
{
int basicArraySize = 2 * IntPtr.Size; // EETypePtr + Length
if (TypeBeingBuilt.IsMdArray)
{
// MD Arrays are arranged like normal arrays, but they also have 2 int's per rank for the individual dimension loBounds and range.
basicArraySize += ((ArrayType)TypeBeingBuilt).Rank * sizeof(int) * 2;
}
return basicArraySize;
}
else
{
return null;
}
}
}
public int? UnalignedTypeSize
{
get
{
DefType defType = TypeBeingBuilt as DefType;
if (defType != null)
{
return defType.InstanceByteCountUnaligned.AsInt;
}
else if (TypeBeingBuilt is ArrayType)
{
// Arrays use the same algorithm for TypeSize as for UnalignedTypeSize
return TypeSize;
}
else
{
return 0;
}
}
}
public int? FieldAlignment
{
get
{
if (TypeBeingBuilt is DefType)
{
return checked((ushort)((DefType)TypeBeingBuilt).InstanceFieldAlignment.AsInt);
}
else if (TypeBeingBuilt is ArrayType)
{
ArrayType arrayType = (ArrayType)TypeBeingBuilt;
if (arrayType.ElementType is DefType)
{
return checked((ushort)((DefType)arrayType.ElementType).InstanceFieldAlignment.AsInt);
}
else
{
return (ushort)arrayType.Context.Target.PointerSize;
}
}
else if (TypeBeingBuilt is PointerType || TypeBeingBuilt is ByRefType)
{
return (ushort)TypeBeingBuilt.Context.Target.PointerSize;
}
else
{
return null;
}
}
}
public ushort? ComponentSize
{
get
{
ArrayType arrayType = TypeBeingBuilt as ArrayType;
if (arrayType != null)
{
if (arrayType.ElementType is DefType)
{
uint size = (uint)((DefType)arrayType.ElementType).InstanceFieldSize.AsInt;
if (size > ArrayTypesConstants.MaxSizeForValueClassInArray && arrayType.ElementType.IsValueType)
ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadValueClassTooLarge, arrayType.ElementType);
return checked((ushort)size);
}
else
{
return (ushort)arrayType.Context.Target.PointerSize;
}
}
else
{
return null;
}
}
}
public uint NullableValueOffset
{
get
{
if (!TypeBeingBuilt.IsNullable)
return 0;
if (TypeBeingBuilt.IsTemplateCanonical())
{
// Pull the GC Desc from the canonical instantiation
TypeDesc templateType = TypeBeingBuilt.ComputeTemplate();
bool success = templateType.RetrieveRuntimeTypeHandleIfPossible();
Debug.Assert(success);
unsafe
{
return templateType.RuntimeTypeHandle.ToEETypePtr()->NullableValueOffset;
}
}
else
{
int fieldCount = 0;
uint nullableValueOffset = 0;
foreach (FieldDesc f in GetFieldsForGCLayout())
{
if (fieldCount == 1)
{
nullableValueOffset = checked((uint)f.Offset.AsInt);
}
fieldCount++;
}
// Nullable<T> only has two fields. HasValue and Value
Debug.Assert(fieldCount == 2);
return nullableValueOffset;
}
}
}
public bool IsHFA
{
get
{
#if TARGET_ARM
if (TypeBeingBuilt.IsValueType && TypeBeingBuilt is DefType)
{
return ((DefType)TypeBeingBuilt).IsHomogeneousAggregate;
}
else
{
return false;
}
#else
// On Non-ARM platforms, HFA'ness is not encoded in the MethodTable as it doesn't effect ABI
return false;
#endif
}
}
public VTableLayoutInfo[] VTableMethodSignatures;
public int NumSealedVTableMethodSignatures;
public VTableSlotMapper VTableSlotsMapping;
#if GENERICS_FORCE_USG
public TypeDesc NonUniversalTemplateType;
public int NonUniversalInstanceGCDescSize;
public IntPtr NonUniversalInstanceGCDesc;
public IntPtr NonUniversalStaticGCDesc;
public IntPtr NonUniversalThreadStaticGCDesc;
#endif
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Text;
using Internal.Runtime;
using Internal.Runtime.Augments;
using Internal.Runtime.CompilerServices;
using Internal.Metadata.NativeFormat;
using Internal.NativeFormat;
using Internal.TypeSystem;
using Internal.TypeSystem.NativeFormat;
using Internal.TypeSystem.NoMetadata;
namespace Internal.Runtime.TypeLoader
{
internal struct NativeLayoutInfo
{
public uint Offset;
public NativeFormatModuleInfo Module;
public NativeReader Reader;
public NativeLayoutInfoLoadContext LoadContext;
}
//
// TypeBuilder per-Type state. It is attached to each TypeDesc that gets involved in type building.
//
internal class TypeBuilderState
{
internal class VTableLayoutInfo
{
public uint VTableSlot;
public RuntimeSignature MethodSignature;
public bool IsSealedVTableSlot;
}
internal class VTableSlotMapper
{
private int[] _slotMap;
private IntPtr[] _dictionarySlots;
private int _numMappingsAssigned;
public VTableSlotMapper(int numVtableSlotsInTemplateType)
{
_slotMap = new int[numVtableSlotsInTemplateType];
_dictionarySlots = new IntPtr[numVtableSlotsInTemplateType];
_numMappingsAssigned = 0;
for (int i = 0; i < numVtableSlotsInTemplateType; i++)
{
_slotMap[i] = -1;
_dictionarySlots[i] = IntPtr.Zero;
}
}
public void AddMapping(int vtableSlotInTemplateType, int vtableSlotInTargetType, IntPtr dictionaryValueInSlot)
{
Debug.Assert(_numMappingsAssigned < _slotMap.Length);
_slotMap[vtableSlotInTemplateType] = vtableSlotInTargetType;
_dictionarySlots[vtableSlotInTemplateType] = dictionaryValueInSlot;
_numMappingsAssigned++;
}
public int GetVTableSlotInTargetType(int vtableSlotInTemplateType)
{
Debug.Assert((uint)vtableSlotInTemplateType < (uint)_slotMap.Length);
return _slotMap[vtableSlotInTemplateType];
}
public bool IsDictionarySlot(int vtableSlotInTemplateType, out IntPtr dictionaryPtrValue)
{
Debug.Assert((uint)vtableSlotInTemplateType < (uint)_dictionarySlots.Length);
dictionaryPtrValue = _dictionarySlots[vtableSlotInTemplateType];
return _dictionarySlots[vtableSlotInTemplateType] != IntPtr.Zero;
}
public int NumSlotMappings
{
get { return _numMappingsAssigned; }
}
}
public TypeBuilderState(TypeDesc typeBeingBuilt)
{
TypeBeingBuilt = typeBeingBuilt;
}
public readonly TypeDesc TypeBeingBuilt;
//
// We cache and try to reuse the most recently used TypeSystemContext. The TypeSystemContext is used by not just type builder itself,
// but also in several random other places in reflection. There can be multiple ResolutionContexts in flight at any given moment.
// This check ensures that the RuntimeTypeHandle cache in the current resolution context is refreshed in case there were new
// types built using a different TypeSystemContext in the meantime.
// NOTE: For correctness, this value must be recomputed every time the context is recycled. This requires flushing the TypeBuilderState
// from each type that has one if context is recycled.
//
public bool AttemptedAndFailedToRetrieveTypeHandle;
public bool NeedsTypeHandle;
public bool HasBeenPrepared;
public RuntimeTypeHandle HalfBakedRuntimeTypeHandle;
public IntPtr HalfBakedDictionary;
public IntPtr HalfBakedSealedVTable;
private bool _templateComputed;
private bool _nativeLayoutTokenComputed;
private TypeDesc _templateType;
public TypeDesc TemplateType
{
get
{
if (!_templateComputed)
{
// Multidimensional arrays and szarrays of pointers don't implement generic interfaces and are special cases. They use
// typeof(object[,]) as their template.
if (TypeBeingBuilt.IsMdArray || (TypeBeingBuilt.IsSzArray && ((ArrayType)TypeBeingBuilt).ElementType.IsPointer))
{
_templateType = TypeBeingBuilt.Context.ResolveRuntimeTypeHandle(typeof(object[,]).TypeHandle);
_templateTypeLoaderNativeLayout = false;
_nativeLayoutComputed = _nativeLayoutTokenComputed = _templateComputed = true;
return _templateType;
}
// Locate the template type and native layout info
_templateType = TypeBeingBuilt.Context.TemplateLookup.TryGetTypeTemplate(TypeBeingBuilt, ref _nativeLayoutInfo);
Debug.Assert(_templateType == null || !_templateType.RuntimeTypeHandle.IsNull());
_templateTypeLoaderNativeLayout = true;
_templateComputed = true;
if ((_templateType != null) && !_templateType.IsCanonicalSubtype(CanonicalFormKind.Universal))
_nativeLayoutTokenComputed = true;
}
return _templateType;
}
}
private bool _nativeLayoutComputed;
private bool _templateTypeLoaderNativeLayout;
private bool _readyToRunNativeLayout;
private NativeLayoutInfo _nativeLayoutInfo;
private NativeLayoutInfo _r2rnativeLayoutInfo;
private void EnsureNativeLayoutInfoComputed()
{
if (!_nativeLayoutComputed)
{
if (!_nativeLayoutTokenComputed)
{
if (!_templateComputed)
{
// Attempt to compute native layout through as a non-ReadyToRun template
object _ = this.TemplateType;
}
if (!_nativeLayoutTokenComputed)
{
TypeBeingBuilt.Context.TemplateLookup.TryGetMetadataNativeLayout(TypeBeingBuilt, out _r2rnativeLayoutInfo.Module, out _r2rnativeLayoutInfo.Offset);
if (_r2rnativeLayoutInfo.Module != null)
_readyToRunNativeLayout = true;
}
_nativeLayoutTokenComputed = true;
}
if (_nativeLayoutInfo.Module != null)
{
FinishInitNativeLayoutInfo(TypeBeingBuilt, ref _nativeLayoutInfo);
}
if (_r2rnativeLayoutInfo.Module != null)
{
FinishInitNativeLayoutInfo(TypeBeingBuilt, ref _r2rnativeLayoutInfo);
}
_nativeLayoutComputed = true;
}
}
/// <summary>
/// Initialize the Reader and LoadContext fields of the native layout info
/// </summary>
/// <param name="type"></param>
/// <param name="nativeLayoutInfo"></param>
private static void FinishInitNativeLayoutInfo(TypeDesc type, ref NativeLayoutInfo nativeLayoutInfo)
{
var nativeLayoutInfoLoadContext = new NativeLayoutInfoLoadContext();
nativeLayoutInfoLoadContext._typeSystemContext = type.Context;
nativeLayoutInfoLoadContext._module = nativeLayoutInfo.Module;
if (type is DefType)
{
nativeLayoutInfoLoadContext._typeArgumentHandles = ((DefType)type).Instantiation;
}
else if (type is ArrayType)
{
nativeLayoutInfoLoadContext._typeArgumentHandles = new Instantiation(new TypeDesc[] { ((ArrayType)type).ElementType });
}
else
{
Debug.Assert(false);
}
nativeLayoutInfoLoadContext._methodArgumentHandles = new Instantiation(null);
nativeLayoutInfo.Reader = TypeLoaderEnvironment.Instance.GetNativeLayoutInfoReader(nativeLayoutInfo.Module.Handle);
nativeLayoutInfo.LoadContext = nativeLayoutInfoLoadContext;
}
public NativeLayoutInfo NativeLayoutInfo
{
get
{
EnsureNativeLayoutInfoComputed();
return _nativeLayoutInfo;
}
}
public NativeLayoutInfo R2RNativeLayoutInfo
{
get
{
EnsureNativeLayoutInfoComputed();
return _r2rnativeLayoutInfo;
}
}
public NativeParser GetParserForNativeLayoutInfo()
{
EnsureNativeLayoutInfoComputed();
if (_templateTypeLoaderNativeLayout)
return new NativeParser(_nativeLayoutInfo.Reader, _nativeLayoutInfo.Offset);
else
return default(NativeParser);
}
public NativeParser GetParserForReadyToRunNativeLayoutInfo()
{
EnsureNativeLayoutInfoComputed();
if (_readyToRunNativeLayout)
return new NativeParser(_r2rnativeLayoutInfo.Reader, _r2rnativeLayoutInfo.Offset);
else
return default(NativeParser);
}
public NativeParser GetParserForUniversalNativeLayoutInfo(out NativeLayoutInfoLoadContext universalLayoutLoadContext, out NativeLayoutInfo universalLayoutInfo)
{
universalLayoutInfo = new NativeLayoutInfo();
universalLayoutLoadContext = null;
TypeDesc universalTemplate = TypeBeingBuilt.Context.TemplateLookup.TryGetUniversalTypeTemplate(TypeBeingBuilt, ref universalLayoutInfo);
if (universalTemplate == null)
return new NativeParser();
FinishInitNativeLayoutInfo(TypeBeingBuilt, ref universalLayoutInfo);
universalLayoutLoadContext = universalLayoutInfo.LoadContext;
return new NativeParser(universalLayoutInfo.Reader, universalLayoutInfo.Offset);
}
// RuntimeInterfaces is the full list of interfaces that the type implements. It can include private internal implementation
// detail interfaces that nothing is known about.
public DefType[] RuntimeInterfaces
{
get
{
// Generic Type Definitions have no runtime interfaces
if (TypeBeingBuilt.IsGenericDefinition)
return null;
return TypeBeingBuilt.RuntimeInterfaces;
}
}
private bool? _hasDictionarySlotInVTable;
private bool ComputeHasDictionarySlotInVTable()
{
if (!TypeBeingBuilt.IsGeneric() && !(TypeBeingBuilt is ArrayType))
return false;
// Generic interfaces always have a dictionary slot
if (TypeBeingBuilt.IsInterface)
return true;
return TypeBeingBuilt.CanShareNormalGenericCode();
}
public bool HasDictionarySlotInVTable
{
get
{
if (_hasDictionarySlotInVTable == null)
{
_hasDictionarySlotInVTable = ComputeHasDictionarySlotInVTable();
}
return _hasDictionarySlotInVTable.Value;
}
}
private bool? _hasDictionaryInVTable;
private bool ComputeHasDictionaryInVTable()
{
if (!HasDictionarySlotInVTable)
return false;
if (TypeBeingBuilt.RetrieveRuntimeTypeHandleIfPossible())
{
// Type was already constructed
return TypeBeingBuilt.RuntimeTypeHandle.GetDictionary() != IntPtr.Zero;
}
else
{
// Type is being newly constructed
if (TemplateType != null)
{
NativeParser parser = GetParserForNativeLayoutInfo();
// Template type loader case
#if GENERICS_FORCE_USG
bool isTemplateUniversalCanon = state.TemplateType.IsCanonicalSubtype(CanonicalFormKind.UniversalCanonLookup);
if (isTemplateUniversalCanon && type.CanShareNormalGenericCode())
{
TypeBuilderState tempState = new TypeBuilderState();
tempState.NativeLayoutInfo = new NativeLayoutInfo();
tempState.TemplateType = type.Context.TemplateLookup.TryGetNonUniversalTypeTemplate(type, ref tempState.NativeLayoutInfo);
if (tempState.TemplateType != null)
{
Debug.Assert(!tempState.TemplateType.IsCanonicalSubtype(CanonicalFormKind.UniversalCanonLookup));
parser = GetNativeLayoutInfoParser(type, ref tempState.NativeLayoutInfo);
}
}
#endif
var dictionaryLayoutParser = parser.GetParserForBagElementKind(BagElementKind.DictionaryLayout);
return !dictionaryLayoutParser.IsNull;
}
else
{
NativeParser parser = GetParserForReadyToRunNativeLayoutInfo();
// ReadyToRun case
// Dictionary is directly encoded instead of the NativeLayout being a collection of bags
if (parser.IsNull)
return false;
// First unsigned value in the native layout is the number of dictionary entries
return parser.GetUnsigned() != 0;
}
}
}
public bool HasDictionaryInVTable
{
get
{
if (_hasDictionaryInVTable == null)
_hasDictionaryInVTable = ComputeHasDictionaryInVTable();
return _hasDictionaryInVTable.Value;
}
}
private ushort? _numVTableSlots;
private ushort ComputeNumVTableSlots()
{
if (TypeBeingBuilt.RetrieveRuntimeTypeHandleIfPossible())
{
unsafe
{
return TypeBeingBuilt.RuntimeTypeHandle.ToEETypePtr()->NumVtableSlots;
}
}
else
{
TypeDesc templateType = TypeBeingBuilt.ComputeTemplate(false);
if (templateType != null)
{
// Template type loader case
if (VTableSlotsMapping != null)
{
return checked((ushort)VTableSlotsMapping.NumSlotMappings);
}
else
{
unsafe
{
if (TypeBeingBuilt.IsMdArray || (TypeBeingBuilt.IsSzArray && ((ArrayType)TypeBeingBuilt).ElementType.IsPointer))
{
// MDArray types and pointer arrays have the same vtable as the System.Array type they "derive" from.
// They do not implement the generic interfaces that make this interesting for normal arrays.
return TypeBeingBuilt.BaseType.GetRuntimeTypeHandle().ToEETypePtr()->NumVtableSlots;
}
else
{
// This should only happen for non-universal templates
Debug.Assert(TypeBeingBuilt.IsTemplateCanonical());
// Canonical template type loader case
return templateType.GetRuntimeTypeHandle().ToEETypePtr()->NumVtableSlots;
}
}
}
}
else
{
// Metadata based type loading.
// Generic Type Definitions have no actual vtable entries
if (TypeBeingBuilt.IsGenericDefinition)
return 0;
// We have at least as many slots as exist on the base type.
ushort numVTableSlots = 0;
checked
{
if (TypeBeingBuilt.BaseType != null)
{
numVTableSlots = TypeBeingBuilt.BaseType.GetOrCreateTypeBuilderState().NumVTableSlots;
}
else
{
// Generic interfaces have a dictionary slot
if (TypeBeingBuilt.IsInterface && TypeBeingBuilt.HasInstantiation)
numVTableSlots = 1;
}
// Interfaces have actual vtable slots
if (TypeBeingBuilt.IsInterface)
return numVTableSlots;
foreach (MethodDesc method in TypeBeingBuilt.GetMethods())
{
#if SUPPORTS_NATIVE_METADATA_TYPE_LOADING
if (LazyVTableResolver.MethodDefinesVTableSlot(method))
numVTableSlots++;
#else
Environment.FailFast("metadata type loader required");
#endif
}
if (HasDictionarySlotInVTable)
numVTableSlots++;
}
return numVTableSlots;
}
}
}
public ushort NumVTableSlots
{
get
{
if (_numVTableSlots == null)
_numVTableSlots = ComputeNumVTableSlots();
return _numVTableSlots.Value;
}
}
public GenericTypeDictionary Dictionary;
public int NonGcDataSize
{
get
{
DefType defType = TypeBeingBuilt as DefType;
// The NonGCStatic fields hold the class constructor data if it exists in the negative space
// of the memory region. The ClassConstructorOffset is negative, so it must be negated to
// determine the extra space that is used.
if (defType != null)
{
return defType.NonGCStaticFieldSize.AsInt - (HasStaticConstructor ? TypeBuilder.ClassConstructorOffset : 0);
}
else
{
return -(HasStaticConstructor ? TypeBuilder.ClassConstructorOffset : 0);
}
}
}
public int GcDataSize
{
get
{
DefType defType = TypeBeingBuilt as DefType;
if (defType != null)
{
return defType.GCStaticFieldSize.AsInt;
}
else
{
return 0;
}
}
}
public int ThreadDataSize
{
get
{
DefType defType = TypeBeingBuilt as DefType;
if (defType != null && !defType.IsGenericDefinition)
{
return defType.ThreadGcStaticFieldSize.AsInt;
}
else
{
// Non-DefType's and GenericEETypeDefinitions do not have static fields of any form
return 0;
}
}
}
public bool HasStaticConstructor
{
get { return TypeBeingBuilt.HasStaticConstructor; }
}
public IntPtr? ClassConstructorPointer;
public IntPtr GcStaticDesc;
public IntPtr GcStaticEEType;
public IntPtr ThreadStaticDesc;
public bool AllocatedStaticGCDesc;
public bool AllocatedThreadStaticGCDesc;
public uint ThreadStaticOffset;
public uint NumSealedVTableEntries;
public GenericVariance[] GenericVarianceFlags;
// Sentinel static to allow us to initialize _instanceLayout to something
// and then detect that InstanceGCLayout should return null
private static LowLevelList<bool> s_emptyLayout = new LowLevelList<bool>();
private LowLevelList<bool> _instanceGCLayout;
/// <summary>
/// The instance gc layout of a dynamically laid out type.
/// null if one of the following is true
/// 1) For an array type:
/// - the type is a reference array
/// 2) For a generic type:
/// - the type has no GC instance fields
/// - the type already has a type handle
/// - the type has a non-universal canonical template
/// - the type has already been constructed
///
/// If the type is a valuetype array, this is the layout of the valuetype held in the array if the type has GC reference fields
/// Otherwise, it is the layout of the fields in the type.
/// </summary>
public LowLevelList<bool> InstanceGCLayout
{
get
{
if (_instanceGCLayout == null)
{
LowLevelList<bool> instanceGCLayout = null;
if (TypeBeingBuilt is ArrayType)
{
if (!IsArrayOfReferenceTypes)
{
ArrayType arrayType = (ArrayType)TypeBeingBuilt;
TypeBuilder.GCLayout elementGcLayout = GetFieldGCLayout(arrayType.ElementType);
if (!elementGcLayout.IsNone)
{
instanceGCLayout = new LowLevelList<bool>();
elementGcLayout.WriteToBitfield(instanceGCLayout, 0);
_instanceGCLayout = instanceGCLayout;
}
}
else
{
// Array of reference type returns null
_instanceGCLayout = s_emptyLayout;
}
}
else if (TypeBeingBuilt.RetrieveRuntimeTypeHandleIfPossible() ||
TypeBeingBuilt.IsTemplateCanonical() ||
(TypeBeingBuilt is PointerType) ||
(TypeBeingBuilt is ByRefType))
{
_instanceGCLayout = s_emptyLayout;
}
else
{
// Generic Type Definitions have no gc layout
if (!(TypeBeingBuilt.IsGenericDefinition))
{
// Copy in from base type
if (!TypeBeingBuilt.IsValueType && (TypeBeingBuilt.BaseType != null))
{
DefType baseType = TypeBeingBuilt.BaseType;
// Capture the gc layout from the base type
TypeBuilder.GCLayout baseTypeLayout = GetInstanceGCLayout(baseType);
if (!baseTypeLayout.IsNone)
{
instanceGCLayout = new LowLevelList<bool>();
baseTypeLayout.WriteToBitfield(instanceGCLayout, IntPtr.Size /* account for the MethodTable pointer */);
}
}
foreach (FieldDesc field in GetFieldsForGCLayout())
{
if (field.IsStatic)
continue;
if (field.IsLiteral)
continue;
TypeBuilder.GCLayout fieldGcLayout = GetFieldGCLayout(field.FieldType);
if (!fieldGcLayout.IsNone)
{
if (instanceGCLayout == null)
instanceGCLayout = new LowLevelList<bool>();
fieldGcLayout.WriteToBitfield(instanceGCLayout, field.Offset.AsInt);
}
}
if ((instanceGCLayout != null) && instanceGCLayout.HasSetBits())
{
// When bits are set in the instance GC layout, it implies that the type contains GC refs,
// which implies that the type size is pointer-aligned. In this case consumers assume that
// the type size can be computed by multiplying the bitfield size by the pointer size. If
// necessary, expand the bitfield to ensure that this invariant holds.
// Valuetypes with gc fields must be aligned on at least pointer boundaries
Debug.Assert(!TypeBeingBuilt.IsValueType || (FieldAlignment.Value >= TypeBeingBuilt.Context.Target.PointerSize));
// Valuetypes with gc fields must have a type size which is aligned on an IntPtr boundary.
Debug.Assert(!TypeBeingBuilt.IsValueType || ((TypeSize.Value & (IntPtr.Size - 1)) == 0));
int impliedBitCount = (TypeSize.Value + IntPtr.Size - 1) / IntPtr.Size;
Debug.Assert(instanceGCLayout.Count <= impliedBitCount);
instanceGCLayout.Expand(impliedBitCount);
Debug.Assert(instanceGCLayout.Count == impliedBitCount);
}
}
if (instanceGCLayout == null)
_instanceGCLayout = s_emptyLayout;
else
_instanceGCLayout = instanceGCLayout;
}
}
if (_instanceGCLayout == s_emptyLayout)
return null;
else
return _instanceGCLayout;
}
}
public LowLevelList<bool> StaticGCLayout;
public LowLevelList<bool> ThreadStaticGCLayout;
private bool _staticGCLayoutPrepared;
/// <summary>
/// Prepare the StaticGCLayout/ThreadStaticGCLayout/GcStaticDesc/ThreadStaticDesc fields by
/// reading native layout or metadata as appropriate. This method should only be called for types which
/// are actually to be created.
/// </summary>
public void PrepareStaticGCLayout()
{
if (!_staticGCLayoutPrepared)
{
_staticGCLayoutPrepared = true;
DefType defType = TypeBeingBuilt as DefType;
if (defType == null)
{
// Array/pointer types do not have static fields
}
else if (defType.IsTemplateCanonical())
{
// Canonical templates get their layout directly from the NativeLayoutInfo.
// Parse it and pull that info out here.
NativeParser typeInfoParser = GetParserForNativeLayoutInfo();
BagElementKind kind;
while ((kind = typeInfoParser.GetBagElementKind()) != BagElementKind.End)
{
switch (kind)
{
case BagElementKind.GcStaticDesc:
GcStaticDesc = NativeLayoutInfo.LoadContext.GetGCStaticInfo(typeInfoParser.GetUnsigned());
break;
case BagElementKind.ThreadStaticDesc:
ThreadStaticDesc = NativeLayoutInfo.LoadContext.GetGCStaticInfo(typeInfoParser.GetUnsigned());
break;
case BagElementKind.GcStaticEEType:
GcStaticEEType = NativeLayoutInfo.LoadContext.GetGCStaticInfo(typeInfoParser.GetUnsigned());
break;
default:
typeInfoParser.SkipInteger();
break;
}
}
}
else
{
// Compute GC layout boolean array from field information.
IEnumerable<FieldDesc> fields = GetFieldsForGCLayout();
LowLevelList<bool> threadStaticLayout = null;
LowLevelList<bool> gcStaticLayout = null;
foreach (FieldDesc field in fields)
{
if (!field.IsStatic)
continue;
if (field.IsLiteral)
continue;
LowLevelList<bool> gcLayoutInfo = null;
if (field.IsThreadStatic)
{
if (threadStaticLayout == null)
threadStaticLayout = new LowLevelList<bool>();
gcLayoutInfo = threadStaticLayout;
}
else if (field.HasGCStaticBase)
{
if (gcStaticLayout == null)
gcStaticLayout = new LowLevelList<bool>();
gcLayoutInfo = gcStaticLayout;
}
else
{
// Non-GC static no need to record information
continue;
}
TypeBuilder.GCLayout fieldGcLayout = GetFieldGCLayout(field.FieldType);
fieldGcLayout.WriteToBitfield(gcLayoutInfo, field.Offset.AsInt);
}
if (gcStaticLayout != null && gcStaticLayout.Count > 0)
StaticGCLayout = gcStaticLayout;
if (threadStaticLayout != null && threadStaticLayout.Count > 0)
ThreadStaticGCLayout = threadStaticLayout;
}
}
}
/// <summary>
/// Get an enumerable list of the fields used for dynamic gc layout calculation.
/// </summary>
private IEnumerable<FieldDesc> GetFieldsForGCLayout()
{
DefType defType = (DefType)TypeBeingBuilt;
IEnumerable<FieldDesc> fields;
if (defType.ComputeTemplate(false) != null)
{
// we have native layout and a template. Use the NativeLayoutFields as that is the only complete
// description of the fields available. (There may be metadata fields, but those aren't guaranteed
// to be a complete set of fields due to reflection reduction.
NativeLayoutFieldAlgorithm.EnsureFieldLayoutLoadedForGenericType(defType);
fields = defType.NativeLayoutFields;
}
else
{
// The metadata case. We're loading the type from regular metadata, so use the regular metadata fields
fields = defType.GetFields();
}
return fields;
}
// Get the GC layout of a type. Handles pre-created, universal template, and non-universal template cases
// Only to be used for getting the instance layout of non-valuetypes.
/// <summary>
/// Get the GC layout of a type. Handles pre-created, universal template, and non-universal template cases
/// Only to be used for getting the instance layout of non-valuetypes that are used as base types
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private unsafe TypeBuilder.GCLayout GetInstanceGCLayout(TypeDesc type)
{
Debug.Assert(!type.IsCanonicalSubtype(CanonicalFormKind.Any));
Debug.Assert(!type.IsValueType);
if (type.RetrieveRuntimeTypeHandleIfPossible())
{
return new TypeBuilder.GCLayout(type.RuntimeTypeHandle);
}
if (type.IsTemplateCanonical())
{
var templateType = type.ComputeTemplate();
bool success = templateType.RetrieveRuntimeTypeHandleIfPossible();
Debug.Assert(success && !templateType.RuntimeTypeHandle.IsNull());
return new TypeBuilder.GCLayout(templateType.RuntimeTypeHandle);
}
else
{
TypeBuilderState state = type.GetOrCreateTypeBuilderState();
if (state.InstanceGCLayout == null)
return TypeBuilder.GCLayout.None;
else
return new TypeBuilder.GCLayout(state.InstanceGCLayout, true);
}
}
/// <summary>
/// Get the GC layout of a type when used as a field.
/// NOTE: if the fieldtype is a reference type, this function will return GCLayout.None
/// Consumers of the api must handle that special case.
/// </summary>
private unsafe TypeBuilder.GCLayout GetFieldGCLayout(TypeDesc fieldType)
{
if (!fieldType.IsValueType)
{
if (fieldType.IsPointer)
return TypeBuilder.GCLayout.None;
else
return TypeBuilder.GCLayout.SingleReference;
}
// Is this a type that already exists? If so, get its gclayout from the MethodTable directly
if (fieldType.RetrieveRuntimeTypeHandleIfPossible())
{
return new TypeBuilder.GCLayout(fieldType.RuntimeTypeHandle);
}
// The type of the field must be a valuetype that is dynamically being constructed
if (fieldType.IsTemplateCanonical())
{
// Pull the GC Desc from the canonical instantiation
TypeDesc templateType = fieldType.ComputeTemplate();
bool success = templateType.RetrieveRuntimeTypeHandleIfPossible();
Debug.Assert(success);
return new TypeBuilder.GCLayout(templateType.RuntimeTypeHandle);
}
else
{
// Use the type builder state's computed InstanceGCLayout
var instanceGCLayout = fieldType.GetOrCreateTypeBuilderState().InstanceGCLayout;
if (instanceGCLayout == null)
return TypeBuilder.GCLayout.None;
return new TypeBuilder.GCLayout(instanceGCLayout, false /* Always represents a valuetype as the reference type case
is handled above with the GCLayout.SingleReference return */);
}
}
public bool IsArrayOfReferenceTypes
{
get
{
ArrayType typeAsArrayType = TypeBeingBuilt as ArrayType;
if (typeAsArrayType != null)
return !typeAsArrayType.ParameterType.IsValueType && !typeAsArrayType.ParameterType.IsPointer;
else
return false;
}
}
// Rank for arrays, -1 is used for an SzArray, and a positive number for a multidimensional array.
public int? ArrayRank
{
get
{
if (!TypeBeingBuilt.IsArray)
return null;
else if (TypeBeingBuilt.IsSzArray)
return -1;
else
{
Debug.Assert(TypeBeingBuilt.IsMdArray);
return ((ArrayType)TypeBeingBuilt).Rank;
}
}
}
public int? BaseTypeSize
{
get
{
if (TypeBeingBuilt.BaseType == null)
{
return null;
}
else
{
return TypeBeingBuilt.BaseType.InstanceByteCountUnaligned.AsInt;
}
}
}
public int? TypeSize
{
get
{
DefType defType = TypeBeingBuilt as DefType;
if (defType != null)
{
// Generic Type Definition EETypes do not have size
if (defType.IsGenericDefinition)
return null;
if (defType.IsValueType)
{
return defType.InstanceFieldSize.AsInt;
}
else
{
if (defType.IsInterface)
return IntPtr.Size;
return defType.InstanceByteCountUnaligned.AsInt;
}
}
else if (TypeBeingBuilt is ArrayType)
{
int basicArraySize = 2 * IntPtr.Size; // EETypePtr + Length
if (TypeBeingBuilt.IsMdArray)
{
// MD Arrays are arranged like normal arrays, but they also have 2 int's per rank for the individual dimension loBounds and range.
basicArraySize += ((ArrayType)TypeBeingBuilt).Rank * sizeof(int) * 2;
}
return basicArraySize;
}
else
{
return null;
}
}
}
public int? UnalignedTypeSize
{
get
{
DefType defType = TypeBeingBuilt as DefType;
if (defType != null)
{
return defType.InstanceByteCountUnaligned.AsInt;
}
else if (TypeBeingBuilt is ArrayType)
{
// Arrays use the same algorithm for TypeSize as for UnalignedTypeSize
return TypeSize;
}
else
{
return 0;
}
}
}
public int? FieldAlignment
{
get
{
if (TypeBeingBuilt is DefType)
{
return checked((ushort)((DefType)TypeBeingBuilt).InstanceFieldAlignment.AsInt);
}
else if (TypeBeingBuilt is ArrayType)
{
ArrayType arrayType = (ArrayType)TypeBeingBuilt;
if (arrayType.ElementType is DefType)
{
return checked((ushort)((DefType)arrayType.ElementType).InstanceFieldAlignment.AsInt);
}
else
{
return (ushort)arrayType.Context.Target.PointerSize;
}
}
else if (TypeBeingBuilt is PointerType || TypeBeingBuilt is ByRefType)
{
return (ushort)TypeBeingBuilt.Context.Target.PointerSize;
}
else
{
return null;
}
}
}
public ushort? ComponentSize
{
get
{
ArrayType arrayType = TypeBeingBuilt as ArrayType;
if (arrayType != null)
{
if (arrayType.ElementType is DefType)
{
uint size = (uint)((DefType)arrayType.ElementType).InstanceFieldSize.AsInt;
if (size > ArrayTypesConstants.MaxSizeForValueClassInArray && arrayType.ElementType.IsValueType)
ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadValueClassTooLarge, arrayType.ElementType);
return checked((ushort)size);
}
else
{
return (ushort)arrayType.Context.Target.PointerSize;
}
}
else
{
return null;
}
}
}
public uint NullableValueOffset
{
get
{
if (!TypeBeingBuilt.IsNullable)
return 0;
if (TypeBeingBuilt.IsTemplateCanonical())
{
// Pull the GC Desc from the canonical instantiation
TypeDesc templateType = TypeBeingBuilt.ComputeTemplate();
bool success = templateType.RetrieveRuntimeTypeHandleIfPossible();
Debug.Assert(success);
unsafe
{
return templateType.RuntimeTypeHandle.ToEETypePtr()->NullableValueOffset;
}
}
else
{
int fieldCount = 0;
uint nullableValueOffset = 0;
foreach (FieldDesc f in GetFieldsForGCLayout())
{
if (fieldCount == 1)
{
nullableValueOffset = checked((uint)f.Offset.AsInt);
}
fieldCount++;
}
// Nullable<T> only has two fields. HasValue and Value
Debug.Assert(fieldCount == 2);
return nullableValueOffset;
}
}
}
public bool IsHFA
{
get
{
#if TARGET_ARM
if (TypeBeingBuilt.IsValueType && TypeBeingBuilt is DefType)
{
return ((DefType)TypeBeingBuilt).IsHomogeneousAggregate;
}
else
{
return false;
}
#else
// On Non-ARM platforms, HFA'ness is not encoded in the MethodTable as it doesn't effect ABI
return false;
#endif
}
}
public VTableLayoutInfo[] VTableMethodSignatures;
public int NumSealedVTableMethodSignatures;
public VTableSlotMapper VTableSlotsMapping;
#if GENERICS_FORCE_USG
public TypeDesc NonUniversalTemplateType;
public int NonUniversalInstanceGCDescSize;
public IntPtr NonUniversalInstanceGCDesc;
public IntPtr NonUniversalStaticGCDesc;
public IntPtr NonUniversalThreadStaticGCDesc;
#endif
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.IO/tests/TestDataProvider/TestDataProvider.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace System.IO.Tests
{
public static class TestDataProvider
{
private static readonly char[] s_charData;
private static readonly char[] s_smallData;
private static readonly char[] s_largeData;
public static object FirstObject { get; } = (object)1;
public static object SecondObject { get; } = (object)"[second object]";
public static object ThirdObject { get; } = (object)"<third object>";
public static object[] MultipleObjects { get; } = new object[] { FirstObject, SecondObject, ThirdObject };
public static string FormatStringOneObject { get; } = "Object is {0}";
public static string FormatStringTwoObjects { get; } = $"Object are '{0}', {SecondObject}";
public static string FormatStringThreeObjects { get; } = $"Objects are {0}, {SecondObject}, {ThirdObject}";
public static string FormatStringMultipleObjects { get; } = "Multiple Objects are: {0}, {1}, {2}";
static TestDataProvider()
{
s_charData = new char[]
{
char.MinValue,
char.MaxValue,
'\t',
' ',
'$',
'@',
'#',
'\0',
'\v',
'\'',
'\u3190',
'\uC3A0',
'A',
'5',
'\r',
'\uFE70',
'-',
';',
'\r',
'\n',
'T',
'3',
'\n',
'K',
'\u00E6'
};
s_smallData = "HELLO".ToCharArray();
var data = new List<char>();
for (int count = 0; count < 1000; ++count)
{
data.AddRange(s_smallData);
}
s_largeData = data.ToArray();
}
public static char[] CharData => s_charData;
public static char[] SmallData => s_smallData;
public static char[] LargeData => s_largeData;
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace System.IO.Tests
{
public static class TestDataProvider
{
private static readonly char[] s_charData;
private static readonly char[] s_smallData;
private static readonly char[] s_largeData;
public static object FirstObject { get; } = (object)1;
public static object SecondObject { get; } = (object)"[second object]";
public static object ThirdObject { get; } = (object)"<third object>";
public static object[] MultipleObjects { get; } = new object[] { FirstObject, SecondObject, ThirdObject };
public static string FormatStringOneObject { get; } = "Object is {0}";
public static string FormatStringTwoObjects { get; } = $"Object are '{0}', {SecondObject}";
public static string FormatStringThreeObjects { get; } = $"Objects are {0}, {SecondObject}, {ThirdObject}";
public static string FormatStringMultipleObjects { get; } = "Multiple Objects are: {0}, {1}, {2}";
static TestDataProvider()
{
s_charData = new char[]
{
char.MinValue,
char.MaxValue,
'\t',
' ',
'$',
'@',
'#',
'\0',
'\v',
'\'',
'\u3190',
'\uC3A0',
'A',
'5',
'\r',
'\uFE70',
'-',
';',
'\r',
'\n',
'T',
'3',
'\n',
'K',
'\u00E6'
};
s_smallData = "HELLO".ToCharArray();
var data = new List<char>();
for (int count = 0; count < 1000; ++count)
{
data.AddRange(s_smallData);
}
s_largeData = data.ToArray();
}
public static char[] CharData => s_charData;
public static char[] SmallData => s_smallData;
public static char[] LargeData => s_largeData;
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.ComponentModel.Composition.Registration/src/System/ComponentModel/Composition/Registration/RegistrationBuilder.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Reflection.Context;
using System.Threading;
namespace System.ComponentModel.Composition.Registration
{
public class RegistrationBuilder : CustomReflectionContext
{
internal sealed class InnerRC : ReflectionContext
{
public override TypeInfo MapType(TypeInfo t) { return t; }
public override Assembly MapAssembly(Assembly a) { return a; }
}
private static readonly ReflectionContext s_inner = new InnerRC();
private static readonly List<object> s_emptyList = new List<object>();
private readonly Lock _lock = new Lock();
private readonly List<PartBuilder> _conventions = new List<PartBuilder>();
private readonly Dictionary<MemberInfo, List<Attribute>> _memberInfos = new Dictionary<MemberInfo, List<Attribute>>();
private readonly Dictionary<ParameterInfo, List<Attribute>> _parameters = new Dictionary<ParameterInfo, List<Attribute>>();
public RegistrationBuilder() : base(s_inner)
{
}
public PartBuilder<T> ForTypesDerivedFrom<T>()
{
var partBuilder = new PartBuilder<T>((t) => typeof(T) != t && typeof(T).IsAssignableFrom(t));
_conventions.Add(partBuilder);
return partBuilder;
}
public PartBuilder ForTypesDerivedFrom(Type type!!)
{
var partBuilder = new PartBuilder((t) => type != t && type.IsAssignableFrom(t));
_conventions.Add(partBuilder);
return partBuilder;
}
public PartBuilder<T> ForType<T>()
{
var partBuilder = new PartBuilder<T>((t) => t == typeof(T));
_conventions.Add(partBuilder);
return partBuilder;
}
public PartBuilder ForType(Type type!!)
{
var partBuilder = new PartBuilder((t) => t == type);
_conventions.Add(partBuilder);
return partBuilder;
}
public PartBuilder<T> ForTypesMatching<T>(Predicate<Type> typeFilter!!)
{
var partBuilder = new PartBuilder<T>(typeFilter);
_conventions.Add(partBuilder);
return partBuilder;
}
public PartBuilder ForTypesMatching(Predicate<Type> typeFilter!!)
{
var partBuilder = new PartBuilder(typeFilter);
_conventions.Add(partBuilder);
return partBuilder;
}
private IEnumerable<Tuple<object, List<Attribute>>> EvaluateThisTypeAgainstTheConvention(Type type)
{
List<Attribute> attributes = new List<Attribute>();
var configuredMembers = new List<Tuple<object, List<Attribute>>>();
bool specifiedConstructor = false;
bool matchedConvention = false;
foreach (PartBuilder builder in _conventions.Where(c => c.SelectType(type.UnderlyingSystemType)))
{
attributes.AddRange(builder.BuildTypeAttributes(type));
specifiedConstructor |= builder.BuildConstructorAttributes(type, ref configuredMembers);
builder.BuildPropertyAttributes(type, ref configuredMembers);
matchedConvention = true;
}
if (matchedConvention && !specifiedConstructor)
{
// DefaultConstructor
PartBuilder.BuildDefaultConstructorAttributes(type, ref configuredMembers);
}
configuredMembers.Add(Tuple.Create((object)type, attributes));
return configuredMembers;
}
// Handle Type Exports and Parts
protected override IEnumerable<object> GetCustomAttributes(System.Reflection.MemberInfo member, IEnumerable<object> declaredAttributes)
{
IEnumerable<object> attributes = base.GetCustomAttributes(member, declaredAttributes);
// Now edit the attributes returned from the base type
List<Attribute> cachedAttributes = null;
if (member.MemberType == MemberTypes.TypeInfo || member.MemberType == MemberTypes.NestedType)
{
MemberInfo underlyingMemberType = ((Type)member).UnderlyingSystemType;
using (new ReadLock(_lock))
{
_memberInfos.TryGetValue(underlyingMemberType, out cachedAttributes);
}
if (cachedAttributes == null)
{
using (new WriteLock(_lock))
{
//Double check locking another thread may have inserted one while we were away.
if (!_memberInfos.TryGetValue(underlyingMemberType, out cachedAttributes))
{
List<Attribute> attributeList;
foreach (Tuple<object, List<Attribute>> element in EvaluateThisTypeAgainstTheConvention((Type)member))
{
attributeList = element.Item2;
if (attributeList != null)
{
if (element.Item1 is MemberInfo)
{
List<Attribute> memberAttributes;
switch (((MemberInfo)element.Item1).MemberType)
{
case MemberTypes.Constructor:
if (!_memberInfos.TryGetValue((MemberInfo)element.Item1, out memberAttributes))
{
_memberInfos.Add((MemberInfo)element.Item1, element.Item2);
}
else
{
memberAttributes.AddRange(attributeList);
}
break;
case MemberTypes.TypeInfo:
case MemberTypes.NestedType:
case MemberTypes.Property:
if (!_memberInfos.TryGetValue((MemberInfo)element.Item1, out memberAttributes))
{
_memberInfos.Add((MemberInfo)element.Item1, element.Item2);
}
else
{
memberAttributes.AddRange(attributeList);
}
break;
default:
break;
}
}
else
{
if (!(element.Item1 is ParameterInfo))
throw new Exception(SR.Diagnostic_InternalExceptionMessage);
// Item contains as Constructor parameter to configure
if (!_parameters.TryGetValue((ParameterInfo)element.Item1, out List<Attribute> parameterAttributes))
{
_parameters.Add((ParameterInfo)element.Item1, element.Item2);
}
else
{
parameterAttributes.AddRange(cachedAttributes);
}
}
}
}
}
// We will have updated all of the MemberInfos by now so lets reload cachedAttributes wiuth the current store
_memberInfos.TryGetValue(underlyingMemberType, out cachedAttributes);
}
}
}
else if (member.MemberType == System.Reflection.MemberTypes.Constructor || member.MemberType == System.Reflection.MemberTypes.Property)
{
cachedAttributes = ReadMemberCustomAttributes(member);
}
return cachedAttributes == null ? attributes : attributes.Concat(cachedAttributes);
}
//This is where ParameterImports will be handled
protected override IEnumerable<object> GetCustomAttributes(System.Reflection.ParameterInfo parameter, IEnumerable<object> declaredAttributes)
{
IEnumerable<object> attributes = base.GetCustomAttributes(parameter, declaredAttributes);
List<Attribute> cachedAttributes = ReadParameterCustomAttributes(parameter);
return cachedAttributes == null ? attributes : attributes.Concat(cachedAttributes);
}
private List<Attribute> ReadMemberCustomAttributes(MemberInfo member)
{
List<Attribute> cachedAttributes = null;
bool getMemberAttributes = false;
// Now edit the attributes returned from the base type
using (new ReadLock(_lock))
{
if (!_memberInfos.TryGetValue(member, out cachedAttributes))
{
// If there is nothing for this member Cache any attributes for the DeclaringType
if (!_memberInfos.TryGetValue(member.DeclaringType.UnderlyingSystemType, out cachedAttributes))
{
// If there is nothing for this parameter look to see if the declaring Member has been cached yet?
// need to do it outside of the lock, so set the flag we'll check it in a bit
getMemberAttributes = true;
}
cachedAttributes = null;
}
}
if (getMemberAttributes)
{
GetCustomAttributes(member.DeclaringType, s_emptyList);
// We should have run the rules for the enclosing parameter so we can again
using (new ReadLock(_lock))
{
_memberInfos.TryGetValue(member, out cachedAttributes);
}
}
return cachedAttributes;
}
private List<Attribute> ReadParameterCustomAttributes(ParameterInfo parameter)
{
List<Attribute> cachedAttributes = null;
bool getMemberAttributes = false;
// Now edit the attributes returned from the base type
using (new ReadLock(_lock))
{
if (!_parameters.TryGetValue(parameter, out cachedAttributes))
{
// If there is nothing for this parameter Cache any attributes for the DeclaringType
if (!_memberInfos.TryGetValue(parameter.Member.DeclaringType, out cachedAttributes))
{
// If there is nothing for this parameter look to see if the declaring Member has been cached yet?
// need to do it outside of the lock, so set the flag we'll check it in a bit
getMemberAttributes = true;
}
cachedAttributes = null;
}
}
if (getMemberAttributes)
{
GetCustomAttributes(parameter.Member.DeclaringType, s_emptyList);
// We should have run the rules for the enclosing parameter so we can again
using (new ReadLock(_lock))
{
_parameters.TryGetValue(parameter, out cachedAttributes);
}
}
return cachedAttributes;
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Reflection.Context;
using System.Threading;
namespace System.ComponentModel.Composition.Registration
{
public class RegistrationBuilder : CustomReflectionContext
{
internal sealed class InnerRC : ReflectionContext
{
public override TypeInfo MapType(TypeInfo t) { return t; }
public override Assembly MapAssembly(Assembly a) { return a; }
}
private static readonly ReflectionContext s_inner = new InnerRC();
private static readonly List<object> s_emptyList = new List<object>();
private readonly Lock _lock = new Lock();
private readonly List<PartBuilder> _conventions = new List<PartBuilder>();
private readonly Dictionary<MemberInfo, List<Attribute>> _memberInfos = new Dictionary<MemberInfo, List<Attribute>>();
private readonly Dictionary<ParameterInfo, List<Attribute>> _parameters = new Dictionary<ParameterInfo, List<Attribute>>();
public RegistrationBuilder() : base(s_inner)
{
}
public PartBuilder<T> ForTypesDerivedFrom<T>()
{
var partBuilder = new PartBuilder<T>((t) => typeof(T) != t && typeof(T).IsAssignableFrom(t));
_conventions.Add(partBuilder);
return partBuilder;
}
public PartBuilder ForTypesDerivedFrom(Type type!!)
{
var partBuilder = new PartBuilder((t) => type != t && type.IsAssignableFrom(t));
_conventions.Add(partBuilder);
return partBuilder;
}
public PartBuilder<T> ForType<T>()
{
var partBuilder = new PartBuilder<T>((t) => t == typeof(T));
_conventions.Add(partBuilder);
return partBuilder;
}
public PartBuilder ForType(Type type!!)
{
var partBuilder = new PartBuilder((t) => t == type);
_conventions.Add(partBuilder);
return partBuilder;
}
public PartBuilder<T> ForTypesMatching<T>(Predicate<Type> typeFilter!!)
{
var partBuilder = new PartBuilder<T>(typeFilter);
_conventions.Add(partBuilder);
return partBuilder;
}
public PartBuilder ForTypesMatching(Predicate<Type> typeFilter!!)
{
var partBuilder = new PartBuilder(typeFilter);
_conventions.Add(partBuilder);
return partBuilder;
}
private IEnumerable<Tuple<object, List<Attribute>>> EvaluateThisTypeAgainstTheConvention(Type type)
{
List<Attribute> attributes = new List<Attribute>();
var configuredMembers = new List<Tuple<object, List<Attribute>>>();
bool specifiedConstructor = false;
bool matchedConvention = false;
foreach (PartBuilder builder in _conventions.Where(c => c.SelectType(type.UnderlyingSystemType)))
{
attributes.AddRange(builder.BuildTypeAttributes(type));
specifiedConstructor |= builder.BuildConstructorAttributes(type, ref configuredMembers);
builder.BuildPropertyAttributes(type, ref configuredMembers);
matchedConvention = true;
}
if (matchedConvention && !specifiedConstructor)
{
// DefaultConstructor
PartBuilder.BuildDefaultConstructorAttributes(type, ref configuredMembers);
}
configuredMembers.Add(Tuple.Create((object)type, attributes));
return configuredMembers;
}
// Handle Type Exports and Parts
protected override IEnumerable<object> GetCustomAttributes(System.Reflection.MemberInfo member, IEnumerable<object> declaredAttributes)
{
IEnumerable<object> attributes = base.GetCustomAttributes(member, declaredAttributes);
// Now edit the attributes returned from the base type
List<Attribute> cachedAttributes = null;
if (member.MemberType == MemberTypes.TypeInfo || member.MemberType == MemberTypes.NestedType)
{
MemberInfo underlyingMemberType = ((Type)member).UnderlyingSystemType;
using (new ReadLock(_lock))
{
_memberInfos.TryGetValue(underlyingMemberType, out cachedAttributes);
}
if (cachedAttributes == null)
{
using (new WriteLock(_lock))
{
//Double check locking another thread may have inserted one while we were away.
if (!_memberInfos.TryGetValue(underlyingMemberType, out cachedAttributes))
{
List<Attribute> attributeList;
foreach (Tuple<object, List<Attribute>> element in EvaluateThisTypeAgainstTheConvention((Type)member))
{
attributeList = element.Item2;
if (attributeList != null)
{
if (element.Item1 is MemberInfo)
{
List<Attribute> memberAttributes;
switch (((MemberInfo)element.Item1).MemberType)
{
case MemberTypes.Constructor:
if (!_memberInfos.TryGetValue((MemberInfo)element.Item1, out memberAttributes))
{
_memberInfos.Add((MemberInfo)element.Item1, element.Item2);
}
else
{
memberAttributes.AddRange(attributeList);
}
break;
case MemberTypes.TypeInfo:
case MemberTypes.NestedType:
case MemberTypes.Property:
if (!_memberInfos.TryGetValue((MemberInfo)element.Item1, out memberAttributes))
{
_memberInfos.Add((MemberInfo)element.Item1, element.Item2);
}
else
{
memberAttributes.AddRange(attributeList);
}
break;
default:
break;
}
}
else
{
if (!(element.Item1 is ParameterInfo))
throw new Exception(SR.Diagnostic_InternalExceptionMessage);
// Item contains as Constructor parameter to configure
if (!_parameters.TryGetValue((ParameterInfo)element.Item1, out List<Attribute> parameterAttributes))
{
_parameters.Add((ParameterInfo)element.Item1, element.Item2);
}
else
{
parameterAttributes.AddRange(cachedAttributes);
}
}
}
}
}
// We will have updated all of the MemberInfos by now so lets reload cachedAttributes wiuth the current store
_memberInfos.TryGetValue(underlyingMemberType, out cachedAttributes);
}
}
}
else if (member.MemberType == System.Reflection.MemberTypes.Constructor || member.MemberType == System.Reflection.MemberTypes.Property)
{
cachedAttributes = ReadMemberCustomAttributes(member);
}
return cachedAttributes == null ? attributes : attributes.Concat(cachedAttributes);
}
//This is where ParameterImports will be handled
protected override IEnumerable<object> GetCustomAttributes(System.Reflection.ParameterInfo parameter, IEnumerable<object> declaredAttributes)
{
IEnumerable<object> attributes = base.GetCustomAttributes(parameter, declaredAttributes);
List<Attribute> cachedAttributes = ReadParameterCustomAttributes(parameter);
return cachedAttributes == null ? attributes : attributes.Concat(cachedAttributes);
}
private List<Attribute> ReadMemberCustomAttributes(MemberInfo member)
{
List<Attribute> cachedAttributes = null;
bool getMemberAttributes = false;
// Now edit the attributes returned from the base type
using (new ReadLock(_lock))
{
if (!_memberInfos.TryGetValue(member, out cachedAttributes))
{
// If there is nothing for this member Cache any attributes for the DeclaringType
if (!_memberInfos.TryGetValue(member.DeclaringType.UnderlyingSystemType, out cachedAttributes))
{
// If there is nothing for this parameter look to see if the declaring Member has been cached yet?
// need to do it outside of the lock, so set the flag we'll check it in a bit
getMemberAttributes = true;
}
cachedAttributes = null;
}
}
if (getMemberAttributes)
{
GetCustomAttributes(member.DeclaringType, s_emptyList);
// We should have run the rules for the enclosing parameter so we can again
using (new ReadLock(_lock))
{
_memberInfos.TryGetValue(member, out cachedAttributes);
}
}
return cachedAttributes;
}
private List<Attribute> ReadParameterCustomAttributes(ParameterInfo parameter)
{
List<Attribute> cachedAttributes = null;
bool getMemberAttributes = false;
// Now edit the attributes returned from the base type
using (new ReadLock(_lock))
{
if (!_parameters.TryGetValue(parameter, out cachedAttributes))
{
// If there is nothing for this parameter Cache any attributes for the DeclaringType
if (!_memberInfos.TryGetValue(parameter.Member.DeclaringType, out cachedAttributes))
{
// If there is nothing for this parameter look to see if the declaring Member has been cached yet?
// need to do it outside of the lock, so set the flag we'll check it in a bit
getMemberAttributes = true;
}
cachedAttributes = null;
}
}
if (getMemberAttributes)
{
GetCustomAttributes(parameter.Member.DeclaringType, s_emptyList);
// We should have run the rules for the enclosing parameter so we can again
using (new ReadLock(_lock))
{
_parameters.TryGetValue(parameter, out cachedAttributes);
}
}
return cachedAttributes;
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.IO.IsolatedStorage/tests/System/IO/IsolatedStorage/CreateFileTests.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Xunit;
namespace System.IO.IsolatedStorage
{
public class CreateFileTests : IsoStorageTest
{
[Fact]
public void CreateFile_ThrowsArgumentNull()
{
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
Assert.Throws<ArgumentNullException>(() => isf.CreateFile(null));
}
}
[Fact]
public void CreateRemovedFile_ThrowsInvalidOperationException()
{
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
isf.Remove();
Assert.Throws<InvalidOperationException>(() => isf.CreateFile("foo"));
}
}
[Fact]
public void CreateFile_ThrowsObjectDisposed()
{
IsolatedStorageFile isf;
using (isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
}
Assert.Throws<ObjectDisposedException>(() => isf.CreateFile("foo"));
}
[Fact]
public void CreateClosedFile_ThrowsInvalidOperationException()
{
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
isf.Close();
Assert.Throws<InvalidOperationException>(() => isf.CreateFile("foo"));
}
}
[Fact]
public void CreateFile_IsolatedStorageException()
{
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
Assert.Throws<IsolatedStorageException>(() => isf.CreateFile("\0bad"));
}
}
[Theory, MemberData(nameof(ValidStores))]
public void CreateFile_Existence(PresetScopes scope)
{
using (var isf = GetPresetScope(scope))
{
string file = "CreateFile_Existence";
string subdirectory = "CreateFile_Existence_Subdirectory";
using (isf.CreateFile(file)) { }
Assert.True(isf.FileExists(file), "file exists");
isf.CreateDirectory(subdirectory);
Assert.True(isf.DirectoryExists(subdirectory), "directory exists");
string nestedFile = Path.Combine(subdirectory, file);
using (isf.CreateFile(nestedFile)) { }
Assert.True(isf.FileExists(nestedFile), "nested file exists");
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Xunit;
namespace System.IO.IsolatedStorage
{
public class CreateFileTests : IsoStorageTest
{
[Fact]
public void CreateFile_ThrowsArgumentNull()
{
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
Assert.Throws<ArgumentNullException>(() => isf.CreateFile(null));
}
}
[Fact]
public void CreateRemovedFile_ThrowsInvalidOperationException()
{
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
isf.Remove();
Assert.Throws<InvalidOperationException>(() => isf.CreateFile("foo"));
}
}
[Fact]
public void CreateFile_ThrowsObjectDisposed()
{
IsolatedStorageFile isf;
using (isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
}
Assert.Throws<ObjectDisposedException>(() => isf.CreateFile("foo"));
}
[Fact]
public void CreateClosedFile_ThrowsInvalidOperationException()
{
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
isf.Close();
Assert.Throws<InvalidOperationException>(() => isf.CreateFile("foo"));
}
}
[Fact]
public void CreateFile_IsolatedStorageException()
{
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
Assert.Throws<IsolatedStorageException>(() => isf.CreateFile("\0bad"));
}
}
[Theory, MemberData(nameof(ValidStores))]
public void CreateFile_Existence(PresetScopes scope)
{
using (var isf = GetPresetScope(scope))
{
string file = "CreateFile_Existence";
string subdirectory = "CreateFile_Existence_Subdirectory";
using (isf.CreateFile(file)) { }
Assert.True(isf.FileExists(file), "file exists");
isf.CreateDirectory(subdirectory);
Assert.True(isf.DirectoryExists(subdirectory), "directory exists");
string nestedFile = Path.Combine(subdirectory, file);
using (isf.CreateFile(nestedFile)) { }
Assert.True(isf.FileExists(nestedFile), "nested file exists");
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/CodeGenBringUpTests/FactorialRec_do.csproj
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>Full</DebugType>
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="FactorialRec.cs" />
</ItemGroup>
</Project>
|
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>Full</DebugType>
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="FactorialRec.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./docs/design/coreclr/jit/GuardedDevirtualization.md
|
# Guarded Devirtualization
## Overview
Guarded devirtualization is a proposed new optimization for the JIT in .NET Core
3.0. This document describes the motivation, initial design sketch, and highlights
various issues needing further investigation.
## Motivation
The .NET Core JIT is able to do a limited amount of devirtualization for virtual
and interface calls. This ability was added in .NET Core 2.0. To devirtualize
the JIT must be able to demonstrate one of two things: either that it knows the
type of some reference exactly (say because it has seen a `newobj`) or that the
declared type of the reference is a `final` class (aka `sealed`). For virtual
calls the JIT can also devirtualize if it can prove the method is marked as `final`.
However, most of the time the JIT is unable to determine exactness or finalness
and so devirtualization fails. Statistics show that currently only around 15% of
virtual call sites can be devirtualized. Result are even more pessimistic for
interface calls, where success rates are around 5%.
There are a variety of reasons for this. The JIT analysis is somewhat weak.
Historically all the JIT cared about was whether some location held **a** reference
type, not a specific reference type. So the current type propagation has been
retrofitted and there are places where types just get lost. The JIT analysis
happens quite early (during importation) and there is only minimal ability to do
data flow analysis at this stage. So for current devirtualization the source of
the type information and the consumption must be fairly close in the code. A
more detailed accounting of some of the shortcomings can be found in
[#7541](https://github.com/dotnet/runtime/issues/7541).
Resolution of these issues will improve the ability of the JIT to devirtualize,
but even the best analysis possible will still miss out on many cases. Some call
sites are truly polymorphic. Some others are truly monomorphic but proving this
would require sophisticated interprocedural analyses that are not practical in
the JIT or in a system as dynamic as the CLR. And some sites are monomorphic in
practice but potentially polymorphic.
As an alternative, when devirtualization fails, the JIT can perform *guarded
devirtualization*. Here the JIT creates an `if-then-else` block set in place of
a virtual or interface call and inserts a runtime type test (or similar) into
the `if` -- the "guard". If the guard test succeeds the JIT knows the type of
the reference, so the `then` block can directly invoke the method corresponding
to that type. If the test fails then the `else` block is executed and this
contains the original virtual or interface call.
The upshot is that the JIT conditionally gains the benefit of devirtualization at
the expense of increased code size, longer JIT times, and slightly longer code
paths around the call. So long as the JIT's guess at the type is somewhat
reasonable, this optimization can improve performance.
## Opportunity
One might imagine that the JIT's guess about the type of the reference has to be
pretty good for devirtualization to pay off. Somewhat surprisingly, at least based
on our initial results, that is not the case.
### Virtual Calls: The Two-Class Case
Given these class declarations:
```C#
class B
{
public virtual int F() { return 33; }
}
class D : B
{
public override int F() { return 44; }
}
```
Suppose we have an array `B[]` that is randomly filled with instances of `B` and
`D` and each element is class `B` with probability `p`. We time how long
it takes to invoke `F` on each member of the array (note the JIT will not ever
be able to devirtualize these calls), and plot the times as a function of `p`.
The result is something like the following:
Modern hardware includes an indirect branch target predictor and we can see it
in action here. When the array element type is predictable (`p` very close to
zero or very close to 1) performance is better. When the element type is
unpredictable (`p` near 0.5) performance is quite a bit worse.
From this we can see that a correctly predicted virtual call requires about
19 time units and worst case incorrect prediction around 55 time units. There is
some timing overhead here too so the real costs are a bit lower.
Now imagine we update the JIT to do guarded devirtualization and check if the
element is indeed type `B`. If so the JIT can call `B.F` directly and in our
prototype the JIT will also inline the call. So we would expect that if the
element types are mostly `B`s (that is if `p` is near 1.0) we'd see very good
performance, and if the element type is mostly `D` (that is `p` near 0.0)
performance should perhaps slightly worse than the un-optimized case as there is
now extra code to run check before the call.
However as you can see the performance of devirtualized case (blue line) is as
good or better than the un-optimized case for all values of `p`. This is perhaps
unexpected and deserves some explanation.
Recall that modern hardware also includes a branch predictor. For small or large
values of `p` this predictor will correctly guess whether the test added by the
JIT will resolve to the `then` or `else` case. For small values of `p` the JIT
guess will be wrong and control will flow to the `else` block. But unlike the
original example, the indirect call here will only see instances of type `D` and
so the indirect branch predictor will work extremely well. So the overhead for
the small `p` case is similar to the well-predicted indirect case without guarded
devirtualization. As `p` increases the branch predictor starts to mispredict and
that costs some cycles. But when it mispredicts control reaches the `then` block
which executes the inlined call. So the cost of misprediction is offset by the
faster execution and the cost stays relatively flat.
As `p` passes 0.5 the branch predictor flips its prediction to prefer the `then`
case. As before mispredicts are costly and send us down the `else` path but there
we still execute a correctly predicted indirect call.
And as `p` approaches 1.0 the cost falls as the branch predictor is almost always
correct and so the cost is simply that of the inlined call.
So oddly enough the guarded devirtualization case shown here does not require any
sort of perf tradeoff. The JIT is better off guessing the more likely case but
even guessing the less likely case can pay off and doesn't hurt performance.
One might suspect at this point that the two class case is a special case and that
the results do not hold up in more complex cases. More on that shortly.
Before moving on, we should point out that virtual calls in the current
CLR are a bit more expensive than in C++, because the CLR uses a two-level method
table. That is, the indirect call sequence is something like:
```asm
000095 mov rax, qword ptr [rcx] ; fetch method table
000098 mov rax, qword ptr [rax+72] ; fetch proper chunk
00009C call qword ptr [rax+32]B:F():int:this ; call indirect
```
This is a chain of 3 dependent loads and so best-case will require at least 3x
the best cache latency (plus any indirect prediction overhead).
So the virtual call costs for the CLR are high. The chunked method table design
was adopted to save space (chunks can be shared by different classes) at the
expense of some performance. And this apparently makes guarded devirtualization
pay off over a wider range of class distributions than one might expect.
And for completeness, the full guarded `if-then-else` sequence measured above is:
```asm
00007A mov rcx, gword ptr [rsi+8*rcx+16] ; fetch array element
00007F mov rax, 0x7FFC9CFB4A90 ; B's method table
000089 cmp qword ptr [rcx], rax ; method table test
00008C jne SHORT G_M30756_IG06 ; jump if class is not B
00008E mov eax, 33 ; inlined B.F
000093 jmp SHORT G_M30756_IG07
G_M30756_IG06:
000095 mov rax, qword ptr [rcx] ; fetch method table
000098 mov rax, qword ptr [rax+72] ; fetch proper chunk
00009C call qword ptr [rax+32]B:F():int:this ; call indirect
G_M30756_IG07:
```
Note there is a redundant load of the method table (hidden in the `cmp`) that
could be eliminated with a bit more work on the prototype. So guarded
devirtualization perf could potentially be even better than is shown above,
especially for smaller values of `p`.
### Virtual Calls: The Three-Class Case
Now to return to the question we asked above: is there something about the two
class case that made guarded devirtualization especially attractive? Read on.
Suppose we introduce a third class into the mix and repeat the above measurement.
There are now two probabilities in play: `p`, the probability that the element
has class `B`, and `p1`, the probability that the element has class `D`, and
there is a third class `E`. To avoid introducing a 3D plot we'll first simply
average the results for the various values of `p1` and plot performance as a
function of `p`:
The right-hand side (`p` near 1.0) looks a lot like the previous chart. This is
not surprising as there are relatively few instances of that third class. But the
middle and left hand side differ and are more costly.
For the un-optimized case (orange) the difference is directly attributable to
the performance of the indirect ranch predictor. Even when `p` is small there
are still two viable branch targets (on average) and some some degree of indirect
misprediction.
For the optimized case we now see that guarded devirtualization performs worse
than no optimization if the JIT's guess is completely wrong. The penalty is not
that bad because the JIT-introduced branch is predictable. But even at very
modest values of `p` guarded devirtualization starts to win out.
Because we've averaged over `p1` you might suspect that we're hiding something.
The following chart shows the min and max values as well as the average, and also
shows the two-class result (dashed lines).
You can see the minimum values are very similar to the two class case; these
are cases where the `p1` is close to 0 or close to 1. And that makes sense because
if there really are only two classes despite the potential of there being three
then we'd expect to see similar results as in the case where there only can be
two classes.
And as noted above, if `p` is high enough then the curves also converge to the
two class case, as the relative mixture of `D` and `E` is doesn't matter: the
predominance of `B` wins out.
For low values of `p` the actual class at the call site is some mixture of `D`
and `E`. Here's some detail (the x axis now shows `p1` and `p` as upper and
lower values respectively).
The worst case for perf for both is when the mixture of `D` and `E` is
unpredictably 50-50 and there are no `B`s. Once we mix in just 10% of `B` then
guarded devirt performs better no matter what distribution we have for the other
two classes. Worst case overhead -- where the JIT guesses a class that never
appears, and the other classes are evenly distributed -- is around 20%.
So it seems reasonable to say that so long as the JIT can make a credible guess
about the possible class -- say a guess that is right at least 10% of the time
-- then there is quite likely a performance benefit to guarded
devirtualization for virtual calls.
We'll need to verify this with more scenarios, but these initial results are
certainly encouraging.
### Virtual Calls: Testing for Multiple Cases
One might deduce from the above that if there are two likely candidates the JIT
should test for each. This is certainly a possibility and in C++ compilers that
do indirect call profiling there are cases where multiple tests are considered
a good idea. But there's also additional code size and another branch.
This is something we'll look into further.
### Interface Calls: The Two Class Case
Interface calls on the CLR are implemented via [Virtual Stub Dispatch](
https://github.com/dotnet/runtime/blob/main/docs/design/coreclr/botr/virtual-stub-dispatch.md
) (aka VSD). Calls are made through an indirection cell that initially points
at a lookup stub. On the first call, the interface target is identified from the
object's method table and the lookup stub is replaced with a dispatch stub that
checks for that specific method table in a manner quite similar to guarded
devirtualization.
If the method table check fails a counter is incremented, and once the counter
reaches a threshold the dispatch stub is replaced with a resolve stub that looks
up the right target in a process-wide hash table.
For interface call sites that are monomorphic, the VSD mechanism (via the dispatch
stub) executes the following code sequence (here for x64)
```asm
; JIT-produced code
;
; set up R11 with interface target info
mov R11, ... ; additional VSD info for call
mov RCX, ... ; dispatch target object
cmp [rcx], rcx ; null check (unnecessary)
call [addr] ; call indirect through indir cell
; dispatch stub
cmp [RCX], targetMT ; check for right method table
jne DISPATCH-FAIL ; bail to resolve stub if check fails (uses R11 info)
jmp targetCode ; else "tail call" the right method
```
At first glance it might appear that adding guarded devirtualization on top of
VSD may not provide much benefit for monomorphic sites. However the guarded
devirtualization test doesn't use an indirection cell and doesn't require R11
setup, may be able to optimize away the null check, and opens the door for
inlining. So it should be slightly cheaper on average and significantly cheaper
in some cases.
(Note [#9027](https://github.com/dotnet/runtime/issues/9027) indicates
we should be able to optimize away the null check in any case).
If the guarded tests fails we've filtered out one method table the dispatch cell
now works well even if a call site alternates between two classes. So we'd expect
the combination of guarded devirtualization and VSD to perform well on the two
class test and only show limitations when faced with mixtures of three or more
classes.
If the guard test always fails we have the up-front cost for the vtable fetch
(which should amortize pretty well with the subsequent fetch in the) stub plus
the predicted not taken branch. So we'd expect the cost for the two-class cases
where the JIT's prediction is always wrong to be a bit higher).
The graph below shows the measured results. To makes sure we're not overly impacted
by residual VSD state we use a fresh call site for each value of p. The solid
orange line is the current cost. The dashed orange line is the corresponding cost
for a virtual call with the same value of p. The solid blue line is the cost with
an up-front guarded test. As noted there is some slowdown when the JIT always
guesses the wrong class, but the break-even point (not shown) is at a relatively
small probability of a correct guess.
### Interface Calls: The Three Class Case
As with virtual calls you may strongly suspect the two class case for interface
calls is special. And you'd be right.
If we mix a third class in as we did above, we see similar changes in the
performance mix for interface calls, as seen below. But also as with virtual calls
the JIT's guess doesn't have to be all that good to see payoffs. At around 10%
correct, guessing wins on average, and around 30% correct guessing is always a
perf win.
### Delegate Speculation
While we have been discussing this topic in the context of virtual calls, the
method is general and can be applied to indirect calls as well. Here the guard
test may just test for a particular function rather than a type.
`Delegate.Invoke` is a special method that can eventually turns into an indirect
call. The JIT could speculate about the possible target of this call. Choosing
a good target here would require some kind of indirect call profiling.
### Calli Speculation
Indirect calls also arise via the `calli` opcode. As with delegates, choosing a
target here likely requires specialized profiling.
### Costs
Given the optimistic take on performance, it is important to remember that
there are also some costs involved to guarded devirtualization: increased code
size and increased JIT time. There may also be some second-order effects on
the local code generation as we've introduced control flow into the method where
it didn't exist previously.
A naive implementation that aggressively performs guarded devirtualization
increases code size overall by about 5% as measured by PMI. JIT time increase
was not measured but should be in that same ballpark. Some assemblies see code
size increasing by as much as 12%.
However the guarded devirtualization only kicks in for about 15% of the methods.
So the average relative size increase in a method with virtual calls is probably
more like 33%.
There may be some inefficiencies in the current prototype that can be fixed to
reduce the code size impact. Aside from the extra method table fetch noted above
the duplicated calls have the same sets of arguments and so we might be able to
amortize argument evaluation costs better. And there are some complexities around
handling return values (especially for implicit by-reference structures) that
likewise might be able to be tightened up.
Nevertheless, blindly optimizing all virtual calls with guarded devirtualization
is not likely the right approach. Something more selective is almost certainly
needed.
However we have done code-expanding optimizations somewhat blindly before, and
we could contain the size growth risk by restricting this optimization to Tier1.
Also PMI can overstate size impact seen in real scenarios as it may over-count
the impact of changes in methods that are always inlined. So we should look at
size increases from some actual scenarios.
And perhaps I'll look at the size impact of loop cloning as a precedent.
## Implementation Considerations
To get the data above and a better feel for the challenges involved we have
implemented a prototype. It is currently located on this branch:
[GuardedDevirtFoundations](https://github.com/AndyAyersMS/coreclr/tree/GuardedDevirtFoundations).
The prototype can introduce guarded devirtualization for some virtual and
interface calls. It supports inlining of the directly invoked method. It uses
the JIT's "best known type" as the class to predict. It also anticipates being
able to query the runtime for implementing classes of an interface.
### Phase Ordering
For the most part, devirtualization is done very early on in the JIT, during
importation. This allows devirtualized calls to subsequently be inlined, and for
devirtualization of call sites in inlinees to take advantage of type information
propagating down into the inlinee from inlined arguments.
We want those same properties to hold for guarded devirtualization candidates.
So conceptually the transformation should happen in the same place. However it is
not possible to introduce new control flow in the importer (ignoring for the moment
the possibility of using question ops). So the actual transformation must be
deferred until sometime after the importer runs and before the inliner runs.
This deferral is a bit problematic as some key bits of importer state are needed
to query the runtime about the properties of a call target. So if we defer the
transformation we need to somehow capture the data needed for these queries and
make it available later. The current prototype uses (abuses?) the inline
candidate information for this. As part of this we require that all speculative
devirtualization sites be treated as inline candidates, at least initially.
This has the side effect of hoisting the call to be a top level (statement)
expression and introduces a return value placeholder.
We currently already have a similar transformation in the JIT, the "fat calli"
transformation needed on CoreRT. This transformation runs at the right time --
after the importer and before the inliner -- and introduces the right kind of
`if-then-else` control flow structure. So the thought is to generalize this to
handle guarded devirtualization as well.
### Recognition
In the prototype, candidates are recognized during the initial importer driven
call to `impDevirtualizeCall`. If the only reason devirtualization fails is lack
of exactness, then the call is marked as a guarded devirtualization candidate.
### Devirtualization
To produce the direct call the prototype updates the `this` passed in the `then`
version of the call so it has the exact predicted type. It then re-invokes
`impDevirtualizeCall` which should now succeed as the type is now exactly
known. The benefit of reuse here is that certain special cases of devirtualization
are now more likely to be handled.
### Inline Candidacy
The prototype currently sets up all virtual and interface calls as potential
inline candidates. One open question is whether it is worth doing guarded
devirtualization simply to introduce a direct call. As an alternative we could
insist that the directly called method also be something that is potentially
inlineable. One can argue that call overhead matters much more for small methods
that are also likely good inline candidates.
The inline candidate info is based on the apparent method invoked at the virtual
site. This is the base method, the one that introduces the virtual slot. So if we
speculatively check for some class and that class overrides, we need to somehow
update the inline info. How to best do this is unclear.
### Return Values
Because the candidate calls are handled as inline candidates, the JIT hoists the
call to a top level expression (which is good) during importation and introduces
a return value placeholder into the place the call occupied in its original tree.
(Oddly we introduce return value placeholders for some calls that don't return a
a value -- we should fix this). The placeholder points back at the call.
When we split the call into two calls we can't keep this structure intact as there
needs to be a 1-1 relationship between call and placeholder. So the prototype
needs to save the return value in a new local and then update the placeholder to
refer to that local. This can be tricky because in some cases we haven't yet settled
on what the actual type of the return value is.
The handling of return values in the early stages of the JIT (arguably, in the entire
JIT) is quite messy. The ABI details bleed through quite early and do so somewhat
unevenly. This mostly impacts methods that return structures as different ABIs have
quite different conventions, and the IR is transformed to reflect those conventions
at different times for un-inlined calls, inlineable calls that end up not getting
inlined, and for calls that get inlined. In particular, structures that are small
enough to be returned by value (in a register or set of registers) need careful
handling.
The prototype skips over such by-value-returning struct methods today. Some of
the logic found in `fgUpdateInlineReturnExpressionPlaceHolder` needs to be pulled
in to properly type the call return value so we can properly type the temp. Or
perhaps we could leverage some of importer-time transformations that are done for
the fat calli cases.
For larger structs we should arrange so that the call(s) write their return values
directly into the new temp, instead of copying the value from wherever they
return it into a temp, to avoid one level of struct copy. Doing so may require
upstream zero init of the return value struct and this should only happen in one
place.
## Open Issues
Here are some of the issues that need to be looked into more carefully.
### Policy
- what is the best mechanism for guessing which class to test for?
- instrument Tier0 code?
- look at types of arguments?
- ask runtime for set of known classes?
- harvest info from runtime caches (VSD)?
- add instrumenting Tier1 to collect data and Tier2 to optimize?
- is there some efficient way to test for class ranges? Currently the JIT is
doing an exact type test. But we really care more about what method is going to
be invoked. So if there is a range of types `D1...DN` that all will invoke some
particular method can we test for them all somehow?
- or should we test the method after the method lookup (possibly worse tradeoff
because of the chunked method table arrangement, also tricky as a method can
have multiple addresses over time. Since many types can share a chunk this
might allow devirtualization over a wider set of classes (good) but we'd lose
knowledge of exact types (bad). Not clear how these tradeoffs play out.
- interaction of guarded devirt with VSD? For interface calls we are sort of
inlining the first level of the VSD into the JITted code.
- revocation or reworking of the guard if the JIT's prediction turns out to bad?
- improve regular devirtualization to reduce need for guarded
devirtualization.
- should we enable this for preJITted code? In preJITted code the target method
table is not a JIT-time constant and must be looked up.
- in the prototype, guarded devirtualization and late devirtualization sometimes
conflict. Say we fail to devirtualize a site, and so expand via guarded devirtualization
guessing some class X. The residual virtual call then may be optimizable via late
devirtualization, and this may discover the actual class. In that case the guarded
devirtualization is not needed. But currently it can't be undone.
- we probably don't want to bother with guarded devirtualization if we can't also
inline. But it takes us several evaluation steps to determine if a call can
be inlined, some of these happening *after* we've done the guarded expansion.
Again this expansion can't be undone.
- so perhaps we need to build an undo capability for the cases where guarded
devirtualization doesn't lead to inlining and/or where late devirtualization also
applies.
### Implementation
- avoid re-fetching method table for latent virtual call (should reduce code
size and improve overall perf win)
- look at how effectively we are sharing argument setup (might reduce code size
and JIT time impact) -- perhaps implement head merging?
- handle return values in full generality
- il offsets
- flag residual calls as not needing null checks
- properly establish inline candidacy
- decide if the refactoring of `InlineCandidateInfo` is the right way to pass
information from importer to the indirect transform phase
### Futures
- can we cover multiple calls with one test? This can happen already if the
subsequent call is introduced via inlining of the directly called method, as we
know the exact type along that path. But for back to back calls to virtual
methods off of the same object it would be nice to do just one test.
- should we test for multiple types? Once we've peeled off the "most likely" case
if the conditional probability of the next most likely case is high it is probably
worth testing for it too. I believe the C++ compiler will test up to 3 candidates
this way... but that's a lot of code expansion.
|
# Guarded Devirtualization
## Overview
Guarded devirtualization is a proposed new optimization for the JIT in .NET Core
3.0. This document describes the motivation, initial design sketch, and highlights
various issues needing further investigation.
## Motivation
The .NET Core JIT is able to do a limited amount of devirtualization for virtual
and interface calls. This ability was added in .NET Core 2.0. To devirtualize
the JIT must be able to demonstrate one of two things: either that it knows the
type of some reference exactly (say because it has seen a `newobj`) or that the
declared type of the reference is a `final` class (aka `sealed`). For virtual
calls the JIT can also devirtualize if it can prove the method is marked as `final`.
However, most of the time the JIT is unable to determine exactness or finalness
and so devirtualization fails. Statistics show that currently only around 15% of
virtual call sites can be devirtualized. Result are even more pessimistic for
interface calls, where success rates are around 5%.
There are a variety of reasons for this. The JIT analysis is somewhat weak.
Historically all the JIT cared about was whether some location held **a** reference
type, not a specific reference type. So the current type propagation has been
retrofitted and there are places where types just get lost. The JIT analysis
happens quite early (during importation) and there is only minimal ability to do
data flow analysis at this stage. So for current devirtualization the source of
the type information and the consumption must be fairly close in the code. A
more detailed accounting of some of the shortcomings can be found in
[#7541](https://github.com/dotnet/runtime/issues/7541).
Resolution of these issues will improve the ability of the JIT to devirtualize,
but even the best analysis possible will still miss out on many cases. Some call
sites are truly polymorphic. Some others are truly monomorphic but proving this
would require sophisticated interprocedural analyses that are not practical in
the JIT or in a system as dynamic as the CLR. And some sites are monomorphic in
practice but potentially polymorphic.
As an alternative, when devirtualization fails, the JIT can perform *guarded
devirtualization*. Here the JIT creates an `if-then-else` block set in place of
a virtual or interface call and inserts a runtime type test (or similar) into
the `if` -- the "guard". If the guard test succeeds the JIT knows the type of
the reference, so the `then` block can directly invoke the method corresponding
to that type. If the test fails then the `else` block is executed and this
contains the original virtual or interface call.
The upshot is that the JIT conditionally gains the benefit of devirtualization at
the expense of increased code size, longer JIT times, and slightly longer code
paths around the call. So long as the JIT's guess at the type is somewhat
reasonable, this optimization can improve performance.
## Opportunity
One might imagine that the JIT's guess about the type of the reference has to be
pretty good for devirtualization to pay off. Somewhat surprisingly, at least based
on our initial results, that is not the case.
### Virtual Calls: The Two-Class Case
Given these class declarations:
```C#
class B
{
public virtual int F() { return 33; }
}
class D : B
{
public override int F() { return 44; }
}
```
Suppose we have an array `B[]` that is randomly filled with instances of `B` and
`D` and each element is class `B` with probability `p`. We time how long
it takes to invoke `F` on each member of the array (note the JIT will not ever
be able to devirtualize these calls), and plot the times as a function of `p`.
The result is something like the following:
Modern hardware includes an indirect branch target predictor and we can see it
in action here. When the array element type is predictable (`p` very close to
zero or very close to 1) performance is better. When the element type is
unpredictable (`p` near 0.5) performance is quite a bit worse.
From this we can see that a correctly predicted virtual call requires about
19 time units and worst case incorrect prediction around 55 time units. There is
some timing overhead here too so the real costs are a bit lower.
Now imagine we update the JIT to do guarded devirtualization and check if the
element is indeed type `B`. If so the JIT can call `B.F` directly and in our
prototype the JIT will also inline the call. So we would expect that if the
element types are mostly `B`s (that is if `p` is near 1.0) we'd see very good
performance, and if the element type is mostly `D` (that is `p` near 0.0)
performance should perhaps slightly worse than the un-optimized case as there is
now extra code to run check before the call.
However as you can see the performance of devirtualized case (blue line) is as
good or better than the un-optimized case for all values of `p`. This is perhaps
unexpected and deserves some explanation.
Recall that modern hardware also includes a branch predictor. For small or large
values of `p` this predictor will correctly guess whether the test added by the
JIT will resolve to the `then` or `else` case. For small values of `p` the JIT
guess will be wrong and control will flow to the `else` block. But unlike the
original example, the indirect call here will only see instances of type `D` and
so the indirect branch predictor will work extremely well. So the overhead for
the small `p` case is similar to the well-predicted indirect case without guarded
devirtualization. As `p` increases the branch predictor starts to mispredict and
that costs some cycles. But when it mispredicts control reaches the `then` block
which executes the inlined call. So the cost of misprediction is offset by the
faster execution and the cost stays relatively flat.
As `p` passes 0.5 the branch predictor flips its prediction to prefer the `then`
case. As before mispredicts are costly and send us down the `else` path but there
we still execute a correctly predicted indirect call.
And as `p` approaches 1.0 the cost falls as the branch predictor is almost always
correct and so the cost is simply that of the inlined call.
So oddly enough the guarded devirtualization case shown here does not require any
sort of perf tradeoff. The JIT is better off guessing the more likely case but
even guessing the less likely case can pay off and doesn't hurt performance.
One might suspect at this point that the two class case is a special case and that
the results do not hold up in more complex cases. More on that shortly.
Before moving on, we should point out that virtual calls in the current
CLR are a bit more expensive than in C++, because the CLR uses a two-level method
table. That is, the indirect call sequence is something like:
```asm
000095 mov rax, qword ptr [rcx] ; fetch method table
000098 mov rax, qword ptr [rax+72] ; fetch proper chunk
00009C call qword ptr [rax+32]B:F():int:this ; call indirect
```
This is a chain of 3 dependent loads and so best-case will require at least 3x
the best cache latency (plus any indirect prediction overhead).
So the virtual call costs for the CLR are high. The chunked method table design
was adopted to save space (chunks can be shared by different classes) at the
expense of some performance. And this apparently makes guarded devirtualization
pay off over a wider range of class distributions than one might expect.
And for completeness, the full guarded `if-then-else` sequence measured above is:
```asm
00007A mov rcx, gword ptr [rsi+8*rcx+16] ; fetch array element
00007F mov rax, 0x7FFC9CFB4A90 ; B's method table
000089 cmp qword ptr [rcx], rax ; method table test
00008C jne SHORT G_M30756_IG06 ; jump if class is not B
00008E mov eax, 33 ; inlined B.F
000093 jmp SHORT G_M30756_IG07
G_M30756_IG06:
000095 mov rax, qword ptr [rcx] ; fetch method table
000098 mov rax, qword ptr [rax+72] ; fetch proper chunk
00009C call qword ptr [rax+32]B:F():int:this ; call indirect
G_M30756_IG07:
```
Note there is a redundant load of the method table (hidden in the `cmp`) that
could be eliminated with a bit more work on the prototype. So guarded
devirtualization perf could potentially be even better than is shown above,
especially for smaller values of `p`.
### Virtual Calls: The Three-Class Case
Now to return to the question we asked above: is there something about the two
class case that made guarded devirtualization especially attractive? Read on.
Suppose we introduce a third class into the mix and repeat the above measurement.
There are now two probabilities in play: `p`, the probability that the element
has class `B`, and `p1`, the probability that the element has class `D`, and
there is a third class `E`. To avoid introducing a 3D plot we'll first simply
average the results for the various values of `p1` and plot performance as a
function of `p`:
The right-hand side (`p` near 1.0) looks a lot like the previous chart. This is
not surprising as there are relatively few instances of that third class. But the
middle and left hand side differ and are more costly.
For the un-optimized case (orange) the difference is directly attributable to
the performance of the indirect ranch predictor. Even when `p` is small there
are still two viable branch targets (on average) and some some degree of indirect
misprediction.
For the optimized case we now see that guarded devirtualization performs worse
than no optimization if the JIT's guess is completely wrong. The penalty is not
that bad because the JIT-introduced branch is predictable. But even at very
modest values of `p` guarded devirtualization starts to win out.
Because we've averaged over `p1` you might suspect that we're hiding something.
The following chart shows the min and max values as well as the average, and also
shows the two-class result (dashed lines).
You can see the minimum values are very similar to the two class case; these
are cases where the `p1` is close to 0 or close to 1. And that makes sense because
if there really are only two classes despite the potential of there being three
then we'd expect to see similar results as in the case where there only can be
two classes.
And as noted above, if `p` is high enough then the curves also converge to the
two class case, as the relative mixture of `D` and `E` is doesn't matter: the
predominance of `B` wins out.
For low values of `p` the actual class at the call site is some mixture of `D`
and `E`. Here's some detail (the x axis now shows `p1` and `p` as upper and
lower values respectively).
The worst case for perf for both is when the mixture of `D` and `E` is
unpredictably 50-50 and there are no `B`s. Once we mix in just 10% of `B` then
guarded devirt performs better no matter what distribution we have for the other
two classes. Worst case overhead -- where the JIT guesses a class that never
appears, and the other classes are evenly distributed -- is around 20%.
So it seems reasonable to say that so long as the JIT can make a credible guess
about the possible class -- say a guess that is right at least 10% of the time
-- then there is quite likely a performance benefit to guarded
devirtualization for virtual calls.
We'll need to verify this with more scenarios, but these initial results are
certainly encouraging.
### Virtual Calls: Testing for Multiple Cases
One might deduce from the above that if there are two likely candidates the JIT
should test for each. This is certainly a possibility and in C++ compilers that
do indirect call profiling there are cases where multiple tests are considered
a good idea. But there's also additional code size and another branch.
This is something we'll look into further.
### Interface Calls: The Two Class Case
Interface calls on the CLR are implemented via [Virtual Stub Dispatch](
https://github.com/dotnet/runtime/blob/main/docs/design/coreclr/botr/virtual-stub-dispatch.md
) (aka VSD). Calls are made through an indirection cell that initially points
at a lookup stub. On the first call, the interface target is identified from the
object's method table and the lookup stub is replaced with a dispatch stub that
checks for that specific method table in a manner quite similar to guarded
devirtualization.
If the method table check fails a counter is incremented, and once the counter
reaches a threshold the dispatch stub is replaced with a resolve stub that looks
up the right target in a process-wide hash table.
For interface call sites that are monomorphic, the VSD mechanism (via the dispatch
stub) executes the following code sequence (here for x64)
```asm
; JIT-produced code
;
; set up R11 with interface target info
mov R11, ... ; additional VSD info for call
mov RCX, ... ; dispatch target object
cmp [rcx], rcx ; null check (unnecessary)
call [addr] ; call indirect through indir cell
; dispatch stub
cmp [RCX], targetMT ; check for right method table
jne DISPATCH-FAIL ; bail to resolve stub if check fails (uses R11 info)
jmp targetCode ; else "tail call" the right method
```
At first glance it might appear that adding guarded devirtualization on top of
VSD may not provide much benefit for monomorphic sites. However the guarded
devirtualization test doesn't use an indirection cell and doesn't require R11
setup, may be able to optimize away the null check, and opens the door for
inlining. So it should be slightly cheaper on average and significantly cheaper
in some cases.
(Note [#9027](https://github.com/dotnet/runtime/issues/9027) indicates
we should be able to optimize away the null check in any case).
If the guarded tests fails we've filtered out one method table the dispatch cell
now works well even if a call site alternates between two classes. So we'd expect
the combination of guarded devirtualization and VSD to perform well on the two
class test and only show limitations when faced with mixtures of three or more
classes.
If the guard test always fails we have the up-front cost for the vtable fetch
(which should amortize pretty well with the subsequent fetch in the) stub plus
the predicted not taken branch. So we'd expect the cost for the two-class cases
where the JIT's prediction is always wrong to be a bit higher).
The graph below shows the measured results. To makes sure we're not overly impacted
by residual VSD state we use a fresh call site for each value of p. The solid
orange line is the current cost. The dashed orange line is the corresponding cost
for a virtual call with the same value of p. The solid blue line is the cost with
an up-front guarded test. As noted there is some slowdown when the JIT always
guesses the wrong class, but the break-even point (not shown) is at a relatively
small probability of a correct guess.
### Interface Calls: The Three Class Case
As with virtual calls you may strongly suspect the two class case for interface
calls is special. And you'd be right.
If we mix a third class in as we did above, we see similar changes in the
performance mix for interface calls, as seen below. But also as with virtual calls
the JIT's guess doesn't have to be all that good to see payoffs. At around 10%
correct, guessing wins on average, and around 30% correct guessing is always a
perf win.
### Delegate Speculation
While we have been discussing this topic in the context of virtual calls, the
method is general and can be applied to indirect calls as well. Here the guard
test may just test for a particular function rather than a type.
`Delegate.Invoke` is a special method that can eventually turns into an indirect
call. The JIT could speculate about the possible target of this call. Choosing
a good target here would require some kind of indirect call profiling.
### Calli Speculation
Indirect calls also arise via the `calli` opcode. As with delegates, choosing a
target here likely requires specialized profiling.
### Costs
Given the optimistic take on performance, it is important to remember that
there are also some costs involved to guarded devirtualization: increased code
size and increased JIT time. There may also be some second-order effects on
the local code generation as we've introduced control flow into the method where
it didn't exist previously.
A naive implementation that aggressively performs guarded devirtualization
increases code size overall by about 5% as measured by PMI. JIT time increase
was not measured but should be in that same ballpark. Some assemblies see code
size increasing by as much as 12%.
However the guarded devirtualization only kicks in for about 15% of the methods.
So the average relative size increase in a method with virtual calls is probably
more like 33%.
There may be some inefficiencies in the current prototype that can be fixed to
reduce the code size impact. Aside from the extra method table fetch noted above
the duplicated calls have the same sets of arguments and so we might be able to
amortize argument evaluation costs better. And there are some complexities around
handling return values (especially for implicit by-reference structures) that
likewise might be able to be tightened up.
Nevertheless, blindly optimizing all virtual calls with guarded devirtualization
is not likely the right approach. Something more selective is almost certainly
needed.
However we have done code-expanding optimizations somewhat blindly before, and
we could contain the size growth risk by restricting this optimization to Tier1.
Also PMI can overstate size impact seen in real scenarios as it may over-count
the impact of changes in methods that are always inlined. So we should look at
size increases from some actual scenarios.
And perhaps I'll look at the size impact of loop cloning as a precedent.
## Implementation Considerations
To get the data above and a better feel for the challenges involved we have
implemented a prototype. It is currently located on this branch:
[GuardedDevirtFoundations](https://github.com/AndyAyersMS/coreclr/tree/GuardedDevirtFoundations).
The prototype can introduce guarded devirtualization for some virtual and
interface calls. It supports inlining of the directly invoked method. It uses
the JIT's "best known type" as the class to predict. It also anticipates being
able to query the runtime for implementing classes of an interface.
### Phase Ordering
For the most part, devirtualization is done very early on in the JIT, during
importation. This allows devirtualized calls to subsequently be inlined, and for
devirtualization of call sites in inlinees to take advantage of type information
propagating down into the inlinee from inlined arguments.
We want those same properties to hold for guarded devirtualization candidates.
So conceptually the transformation should happen in the same place. However it is
not possible to introduce new control flow in the importer (ignoring for the moment
the possibility of using question ops). So the actual transformation must be
deferred until sometime after the importer runs and before the inliner runs.
This deferral is a bit problematic as some key bits of importer state are needed
to query the runtime about the properties of a call target. So if we defer the
transformation we need to somehow capture the data needed for these queries and
make it available later. The current prototype uses (abuses?) the inline
candidate information for this. As part of this we require that all speculative
devirtualization sites be treated as inline candidates, at least initially.
This has the side effect of hoisting the call to be a top level (statement)
expression and introduces a return value placeholder.
We currently already have a similar transformation in the JIT, the "fat calli"
transformation needed on CoreRT. This transformation runs at the right time --
after the importer and before the inliner -- and introduces the right kind of
`if-then-else` control flow structure. So the thought is to generalize this to
handle guarded devirtualization as well.
### Recognition
In the prototype, candidates are recognized during the initial importer driven
call to `impDevirtualizeCall`. If the only reason devirtualization fails is lack
of exactness, then the call is marked as a guarded devirtualization candidate.
### Devirtualization
To produce the direct call the prototype updates the `this` passed in the `then`
version of the call so it has the exact predicted type. It then re-invokes
`impDevirtualizeCall` which should now succeed as the type is now exactly
known. The benefit of reuse here is that certain special cases of devirtualization
are now more likely to be handled.
### Inline Candidacy
The prototype currently sets up all virtual and interface calls as potential
inline candidates. One open question is whether it is worth doing guarded
devirtualization simply to introduce a direct call. As an alternative we could
insist that the directly called method also be something that is potentially
inlineable. One can argue that call overhead matters much more for small methods
that are also likely good inline candidates.
The inline candidate info is based on the apparent method invoked at the virtual
site. This is the base method, the one that introduces the virtual slot. So if we
speculatively check for some class and that class overrides, we need to somehow
update the inline info. How to best do this is unclear.
### Return Values
Because the candidate calls are handled as inline candidates, the JIT hoists the
call to a top level expression (which is good) during importation and introduces
a return value placeholder into the place the call occupied in its original tree.
(Oddly we introduce return value placeholders for some calls that don't return a
a value -- we should fix this). The placeholder points back at the call.
When we split the call into two calls we can't keep this structure intact as there
needs to be a 1-1 relationship between call and placeholder. So the prototype
needs to save the return value in a new local and then update the placeholder to
refer to that local. This can be tricky because in some cases we haven't yet settled
on what the actual type of the return value is.
The handling of return values in the early stages of the JIT (arguably, in the entire
JIT) is quite messy. The ABI details bleed through quite early and do so somewhat
unevenly. This mostly impacts methods that return structures as different ABIs have
quite different conventions, and the IR is transformed to reflect those conventions
at different times for un-inlined calls, inlineable calls that end up not getting
inlined, and for calls that get inlined. In particular, structures that are small
enough to be returned by value (in a register or set of registers) need careful
handling.
The prototype skips over such by-value-returning struct methods today. Some of
the logic found in `fgUpdateInlineReturnExpressionPlaceHolder` needs to be pulled
in to properly type the call return value so we can properly type the temp. Or
perhaps we could leverage some of importer-time transformations that are done for
the fat calli cases.
For larger structs we should arrange so that the call(s) write their return values
directly into the new temp, instead of copying the value from wherever they
return it into a temp, to avoid one level of struct copy. Doing so may require
upstream zero init of the return value struct and this should only happen in one
place.
## Open Issues
Here are some of the issues that need to be looked into more carefully.
### Policy
- what is the best mechanism for guessing which class to test for?
- instrument Tier0 code?
- look at types of arguments?
- ask runtime for set of known classes?
- harvest info from runtime caches (VSD)?
- add instrumenting Tier1 to collect data and Tier2 to optimize?
- is there some efficient way to test for class ranges? Currently the JIT is
doing an exact type test. But we really care more about what method is going to
be invoked. So if there is a range of types `D1...DN` that all will invoke some
particular method can we test for them all somehow?
- or should we test the method after the method lookup (possibly worse tradeoff
because of the chunked method table arrangement, also tricky as a method can
have multiple addresses over time. Since many types can share a chunk this
might allow devirtualization over a wider set of classes (good) but we'd lose
knowledge of exact types (bad). Not clear how these tradeoffs play out.
- interaction of guarded devirt with VSD? For interface calls we are sort of
inlining the first level of the VSD into the JITted code.
- revocation or reworking of the guard if the JIT's prediction turns out to bad?
- improve regular devirtualization to reduce need for guarded
devirtualization.
- should we enable this for preJITted code? In preJITted code the target method
table is not a JIT-time constant and must be looked up.
- in the prototype, guarded devirtualization and late devirtualization sometimes
conflict. Say we fail to devirtualize a site, and so expand via guarded devirtualization
guessing some class X. The residual virtual call then may be optimizable via late
devirtualization, and this may discover the actual class. In that case the guarded
devirtualization is not needed. But currently it can't be undone.
- we probably don't want to bother with guarded devirtualization if we can't also
inline. But it takes us several evaluation steps to determine if a call can
be inlined, some of these happening *after* we've done the guarded expansion.
Again this expansion can't be undone.
- so perhaps we need to build an undo capability for the cases where guarded
devirtualization doesn't lead to inlining and/or where late devirtualization also
applies.
### Implementation
- avoid re-fetching method table for latent virtual call (should reduce code
size and improve overall perf win)
- look at how effectively we are sharing argument setup (might reduce code size
and JIT time impact) -- perhaps implement head merging?
- handle return values in full generality
- il offsets
- flag residual calls as not needing null checks
- properly establish inline candidacy
- decide if the refactoring of `InlineCandidateInfo` is the right way to pass
information from importer to the indirect transform phase
### Futures
- can we cover multiple calls with one test? This can happen already if the
subsequent call is introduced via inlining of the directly called method, as we
know the exact type along that path. But for back to back calls to virtual
methods off of the same object it would be nice to do just one test.
- should we test for multiple types? Once we've peeled off the "most likely" case
if the conditional probability of the next most likely case is high it is probably
worth testing for it too. I believe the C++ compiler will test up to 3 candidates
this way... but that's a lot of code expansion.
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Diagnostics.PerformanceCounter/src/System/Diagnostics/SharedPerformanceCounter.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Text;
using System.Threading;
using System.Collections;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;
namespace System.Diagnostics
{
internal sealed class SharedPerformanceCounter
{
private const int MaxSpinCount = 5000;
internal const int DefaultCountersFileMappingSize = 524288;
internal const int MaxCountersFileMappingSize = 33554432;
internal const int MinCountersFileMappingSize = 32768;
internal const int InstanceNameMaxLength = 127;
internal const int InstanceNameSlotSize = 256;
internal const string SingleInstanceName = "systemdiagnosticssharedsingleinstance";
internal const string DefaultFileMappingName = "netfxcustomperfcounters.1.0";
internal static readonly int s_singleInstanceHashCode = GetWstrHashCode(SingleInstanceName);
private static readonly Hashtable s_categoryDataTable = new Hashtable(StringComparer.Ordinal);
private static readonly int s_categoryEntrySize = Marshal.SizeOf(typeof(CategoryEntry));
private static readonly int s_instanceEntrySize = Marshal.SizeOf(typeof(InstanceEntry));
private static readonly int s_counterEntrySize = Marshal.SizeOf(typeof(CounterEntry));
private static readonly int s_processLifetimeEntrySize = Marshal.SizeOf(typeof(ProcessLifetimeEntry));
private static long s_lastInstanceLifetimeSweepTick;
private const long InstanceLifetimeSweepWindow = 30 * 10000000; //ticks
private static volatile ProcessData s_procData;
private static ProcessData ProcessData
{
get
{
if (s_procData == null)
{
try
{
int pid = (int)Interop.Kernel32.GetCurrentProcessId();
long startTime = -1;
// Though we have asserted the required CAS permissions above, we may
// still fail to query the process information if the user does not
// have the necessary process access rights or privileges.
// This might be the case if the current process was started by a
// different user (primary token) than the current user
// (impersonation token) that has less privilege/ACL rights.
using (SafeProcessHandle procHandle = Interop.Kernel32.OpenProcess(Interop.Advapi32.ProcessOptions.PROCESS_QUERY_INFORMATION, false, pid))
{
if (!procHandle.IsInvalid)
{
long temp;
Interop.Kernel32.GetProcessTimes(procHandle, out startTime, out temp, out temp, out temp);
}
}
s_procData = new ProcessData(pid, startTime);
}
finally
{
}
}
return s_procData;
}
}
// InitialOffset is the offset in our global shared memory where we put the first CategoryEntry. It needs to be 4 because in
// v1.0 and v1.1 we used IntPtr.Size. That creates potential side-by-side issues on 64 bit machines using WOW64.
// A v1.0 app running on WOW64 will assume the InitialOffset is 4. A true 64 bit app on the same machine will assume
// the initial offset is 8.
// However, using an offset of 4 means that our CounterEntry.Value is potentially misaligned. This is why we have SetValue
// and other methods which split CounterEntry.Value into two ints. With separate shared memory blocks per
// category, we can fix this and always use an inital offset of 8.
internal int _initialOffset = 4;
private readonly CategoryData _categoryData;
private long _baseAddress;
private readonly unsafe CounterEntry* _counterEntryPointer;
private readonly string _categoryName;
private readonly int _categoryNameHashCode;
private int _thisInstanceOffset = -1;
internal SharedPerformanceCounter(string catName, string counterName, string instanceName) :
this(catName, counterName, instanceName, PerformanceCounterInstanceLifetime.Global)
{ }
internal unsafe SharedPerformanceCounter(string catName, string counterName, string instanceName, PerformanceCounterInstanceLifetime lifetime)
{
_categoryName = catName;
_categoryNameHashCode = GetWstrHashCode(_categoryName);
_categoryData = GetCategoryData();
// Check that the instance name isn't too long if we're using the new shared memory.
// We allocate InstanceNameSlotSize bytes in the shared memory
if (_categoryData.UseUniqueSharedMemory)
{
if (instanceName != null && instanceName.Length > InstanceNameMaxLength)
throw new InvalidOperationException(SR.InstanceNameTooLong);
}
else
{
if (lifetime != PerformanceCounterInstanceLifetime.Global)
throw new InvalidOperationException(SR.ProcessLifetimeNotValidInGlobal);
}
if (counterName != null && instanceName != null)
{
if (!_categoryData.CounterNames.Contains(counterName))
Debug.Fail("Counter " + counterName + " does not exist in category " + catName);
else
_counterEntryPointer = GetCounter(counterName, instanceName, _categoryData.EnableReuse, lifetime);
}
}
private FileMapping FileView
{
get
{
return _categoryData.FileMapping;
}
}
internal unsafe long Value
{
get
{
if (_counterEntryPointer == null)
return 0;
return GetValue(_counterEntryPointer);
}
set
{
if (_counterEntryPointer == null)
return;
SetValue(_counterEntryPointer, value);
}
}
private unsafe int CalculateAndAllocateMemory(int totalSize, out int alignmentAdjustment)
{
int newOffset;
int oldOffset;
alignmentAdjustment = 0;
Debug.Assert(!_categoryData.UseUniqueSharedMemory, "We should never be calling CalculateAndAllocateMemory in the unique shared memory");
do
{
oldOffset = *((int*)_baseAddress);
// we need to verify the oldOffset before we start using it. Otherwise someone could change
// it to something bogus and we would write outside of the shared memory.
ResolveOffset(oldOffset, 0);
newOffset = CalculateMemory(oldOffset, totalSize, out alignmentAdjustment);
// In the default shared mem we need to make sure that the end address is also aligned. This is because
// in v1.1/v1.0 we just assumed that the next free offset was always properly aligned.
int endAddressMod8 = (int)(_baseAddress + newOffset) & 0x7;
int endAlignmentAdjustment = (8 - endAddressMod8) & 0x7;
newOffset += endAlignmentAdjustment;
} while (Interlocked.CompareExchange(ref *(int*)((IntPtr)_baseAddress).ToPointer(), newOffset, oldOffset) != oldOffset);
return oldOffset;
}
private int CalculateMemory(int oldOffset, int totalSize, out int alignmentAdjustment)
{
int newOffset = CalculateMemoryNoBoundsCheck(oldOffset, totalSize, out alignmentAdjustment);
if (newOffset > FileView._fileMappingSize || newOffset < 0)
{
throw new InvalidOperationException(SR.CountersOOM);
}
return newOffset;
}
private int CalculateMemoryNoBoundsCheck(int oldOffset, int totalSize, out int alignmentAdjustment)
{
int currentTotalSize = totalSize;
Thread.MemoryBarrier();
// make sure the start address is 8 byte aligned
int startAddressMod8 = (int)(_baseAddress + oldOffset) & 0x7;
alignmentAdjustment = (8 - startAddressMod8) & 0x7;
currentTotalSize = currentTotalSize + alignmentAdjustment;
int newOffset = oldOffset + currentTotalSize;
return newOffset;
}
private unsafe int CreateCategory(CategoryEntry* lastCategoryPointer,
int instanceNameHashCode, string instanceName,
PerformanceCounterInstanceLifetime lifetime)
{
int categoryNameLength;
int instanceNameLength;
int alignmentAdjustment;
int freeMemoryOffset;
int newOffset = 0;
int totalSize;
categoryNameLength = (_categoryName.Length + 1) * 2;
totalSize = s_categoryEntrySize + s_instanceEntrySize + (s_counterEntrySize * _categoryData.CounterNames.Count) + categoryNameLength;
for (int i = 0; i < _categoryData.CounterNames.Count; i++)
{
totalSize += (((string)_categoryData.CounterNames[i]).Length + 1) * 2;
}
if (_categoryData.UseUniqueSharedMemory)
{
instanceNameLength = InstanceNameSlotSize;
totalSize += s_processLifetimeEntrySize + instanceNameLength;
// If we're in a separate shared memory, we need to do a two stage update of the free memory pointer.
// First we calculate our alignment adjustment and where the new free offset is. Then we
// write the new structs and data. The last two operations are to link the new structs into the
// existing ones and update the next free offset. Our process could get killed in between those two,
// leaving the memory in an inconsistent state. We use the "IsConsistent" flag to help determine
// when that has happened.
freeMemoryOffset = *((int*)_baseAddress);
newOffset = CalculateMemory(freeMemoryOffset, totalSize, out alignmentAdjustment);
if (freeMemoryOffset == _initialOffset)
lastCategoryPointer->IsConsistent = 0;
}
else
{
instanceNameLength = (instanceName.Length + 1) * 2;
totalSize += instanceNameLength;
freeMemoryOffset = CalculateAndAllocateMemory(totalSize, out alignmentAdjustment);
}
long nextPtr = ResolveOffset(freeMemoryOffset, totalSize + alignmentAdjustment);
CategoryEntry* newCategoryEntryPointer;
InstanceEntry* newInstanceEntryPointer;
// We need to decide where to put the padding returned in alignmentAdjustment. There are several things that
// need to be aligned. First, we need to align each struct on a 4 byte boundary so we can use interlocked
// operations on the int Spinlock field. Second, we need to align the CounterEntry on an 8 byte boundary so that
// on 64 bit platforms we can use interlocked operations on the Value field. alignmentAdjustment guarantees 8 byte
// alignemnt, so we use that for both. If we're creating the very first category, however, we can't move that
// CategoryEntry. In this case we put the alignmentAdjustment before the InstanceEntry.
if (freeMemoryOffset == _initialOffset)
{
newCategoryEntryPointer = (CategoryEntry*)nextPtr;
nextPtr += s_categoryEntrySize + alignmentAdjustment;
newInstanceEntryPointer = (InstanceEntry*)nextPtr;
}
else
{
nextPtr += alignmentAdjustment;
newCategoryEntryPointer = (CategoryEntry*)nextPtr;
nextPtr += s_categoryEntrySize;
newInstanceEntryPointer = (InstanceEntry*)nextPtr;
}
nextPtr += s_instanceEntrySize;
// create the first CounterEntry and reserve space for all of the rest. We won't
// finish creating them until the end
CounterEntry* newCounterEntryPointer = (CounterEntry*)nextPtr;
nextPtr += s_counterEntrySize * _categoryData.CounterNames.Count;
if (_categoryData.UseUniqueSharedMemory)
{
ProcessLifetimeEntry* newLifetimeEntry = (ProcessLifetimeEntry*)nextPtr;
nextPtr += s_processLifetimeEntrySize;
newCounterEntryPointer->LifetimeOffset = (int)((long)newLifetimeEntry - _baseAddress);
PopulateLifetimeEntry(newLifetimeEntry, lifetime);
}
newCategoryEntryPointer->CategoryNameHashCode = _categoryNameHashCode;
newCategoryEntryPointer->NextCategoryOffset = 0;
newCategoryEntryPointer->FirstInstanceOffset = (int)((long)newInstanceEntryPointer - _baseAddress);
newCategoryEntryPointer->CategoryNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(_categoryName, (IntPtr)nextPtr);
nextPtr += categoryNameLength;
newInstanceEntryPointer->InstanceNameHashCode = instanceNameHashCode;
newInstanceEntryPointer->NextInstanceOffset = 0;
newInstanceEntryPointer->FirstCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
newInstanceEntryPointer->RefCount = 1;
newInstanceEntryPointer->InstanceNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(instanceName, (IntPtr)nextPtr);
nextPtr += instanceNameLength;
string counterName = (string)_categoryData.CounterNames[0];
newCounterEntryPointer->CounterNameHashCode = GetWstrHashCode(counterName);
SetValue(newCounterEntryPointer, 0);
newCounterEntryPointer->CounterNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(counterName, (IntPtr)nextPtr);
nextPtr += (counterName.Length + 1) * 2;
CounterEntry* previousCounterEntryPointer;
for (int i = 1; i < _categoryData.CounterNames.Count; i++)
{
previousCounterEntryPointer = newCounterEntryPointer;
counterName = (string)_categoryData.CounterNames[i];
newCounterEntryPointer++;
newCounterEntryPointer->CounterNameHashCode = GetWstrHashCode(counterName);
SetValue(newCounterEntryPointer, 0);
newCounterEntryPointer->CounterNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(counterName, (IntPtr)nextPtr);
nextPtr += (counterName.Length + 1) * 2;
previousCounterEntryPointer->NextCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
}
Debug.Assert(nextPtr - _baseAddress == freeMemoryOffset + totalSize + alignmentAdjustment, "We should have used all of the space we requested at this point");
int offset = (int)((long)newCategoryEntryPointer - _baseAddress);
lastCategoryPointer->IsConsistent = 0;
// If not the first category node, link it.
if (offset != _initialOffset)
lastCategoryPointer->NextCategoryOffset = offset;
if (_categoryData.UseUniqueSharedMemory)
{
*((int*)_baseAddress) = newOffset;
lastCategoryPointer->IsConsistent = 1;
}
return offset;
}
private unsafe int CreateInstance(CategoryEntry* categoryPointer,
int instanceNameHashCode, string instanceName,
PerformanceCounterInstanceLifetime lifetime)
{
int instanceNameLength;
int totalSize = s_instanceEntrySize + (s_counterEntrySize * _categoryData.CounterNames.Count);
int alignmentAdjustment;
int freeMemoryOffset;
int newOffset = 0;
if (_categoryData.UseUniqueSharedMemory)
{
instanceNameLength = InstanceNameSlotSize;
totalSize += s_processLifetimeEntrySize + instanceNameLength;
// If we're in a separate shared memory, we need to do a two stage update of the free memory pointer.
// First we calculate our alignment adjustment and where the new free offset is. Then we
// write the new structs and data. The last two operations are to link the new structs into the
// existing ones and update the next free offset. Our process could get killed in between those two,
// leaving the memory in an inconsistent state. We use the "IsConsistent" flag to help determine
// when that has happened.
freeMemoryOffset = *((int*)_baseAddress);
newOffset = CalculateMemory(freeMemoryOffset, totalSize, out alignmentAdjustment);
}
else
{
instanceNameLength = (instanceName.Length + 1) * 2;
totalSize += instanceNameLength;
// add in the counter names for the global shared mem.
for (int i = 0; i < _categoryData.CounterNames.Count; i++)
{
totalSize += (((string)_categoryData.CounterNames[i]).Length + 1) * 2;
}
freeMemoryOffset = CalculateAndAllocateMemory(totalSize, out alignmentAdjustment);
}
freeMemoryOffset += alignmentAdjustment;
long nextPtr = ResolveOffset(freeMemoryOffset, totalSize); // don't add alignmentAdjustment since it's already
// been added to freeMemoryOffset
InstanceEntry* newInstanceEntryPointer = (InstanceEntry*)nextPtr;
nextPtr += s_instanceEntrySize;
// create the first CounterEntry and reserve space for all of the rest. We won't
// finish creating them until the end
CounterEntry* newCounterEntryPointer = (CounterEntry*)nextPtr;
nextPtr += s_counterEntrySize * _categoryData.CounterNames.Count;
if (_categoryData.UseUniqueSharedMemory)
{
ProcessLifetimeEntry* newLifetimeEntry = (ProcessLifetimeEntry*)nextPtr;
nextPtr += s_processLifetimeEntrySize;
newCounterEntryPointer->LifetimeOffset = (int)((long)newLifetimeEntry - _baseAddress);
PopulateLifetimeEntry(newLifetimeEntry, lifetime);
}
// set up the InstanceEntry
newInstanceEntryPointer->InstanceNameHashCode = instanceNameHashCode;
newInstanceEntryPointer->NextInstanceOffset = 0;
newInstanceEntryPointer->FirstCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
newInstanceEntryPointer->RefCount = 1;
newInstanceEntryPointer->InstanceNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(instanceName, (IntPtr)nextPtr);
nextPtr += instanceNameLength;
if (_categoryData.UseUniqueSharedMemory)
{
// in the unique shared mem we'll assume that the CounterEntries of the first instance
// are all created. Then we can just refer to the old counter name rather than copying in a new one.
InstanceEntry* firstInstanceInCategoryPointer = (InstanceEntry*)ResolveOffset(categoryPointer->FirstInstanceOffset, s_instanceEntrySize);
CounterEntry* firstCounterInCategoryPointer = (CounterEntry*)ResolveOffset(firstInstanceInCategoryPointer->FirstCounterOffset, s_counterEntrySize);
newCounterEntryPointer->CounterNameHashCode = firstCounterInCategoryPointer->CounterNameHashCode;
SetValue(newCounterEntryPointer, 0);
newCounterEntryPointer->CounterNameOffset = firstCounterInCategoryPointer->CounterNameOffset;
// now create the rest of the CounterEntrys
CounterEntry* previousCounterEntryPointer;
for (int i = 1; i < _categoryData.CounterNames.Count; i++)
{
previousCounterEntryPointer = newCounterEntryPointer;
newCounterEntryPointer++;
Debug.Assert(firstCounterInCategoryPointer->NextCounterOffset != 0, "The unique shared memory should have all of its counters created by the time we hit CreateInstance");
firstCounterInCategoryPointer = (CounterEntry*)ResolveOffset(firstCounterInCategoryPointer->NextCounterOffset, s_counterEntrySize);
newCounterEntryPointer->CounterNameHashCode = firstCounterInCategoryPointer->CounterNameHashCode;
SetValue(newCounterEntryPointer, 0);
newCounterEntryPointer->CounterNameOffset = firstCounterInCategoryPointer->CounterNameOffset;
previousCounterEntryPointer->NextCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
}
}
else
{
// now create the rest of the CounterEntrys
CounterEntry* previousCounterEntryPointer = null;
for (int i = 0; i < _categoryData.CounterNames.Count; i++)
{
string counterName = (string)_categoryData.CounterNames[i];
newCounterEntryPointer->CounterNameHashCode = GetWstrHashCode(counterName);
newCounterEntryPointer->CounterNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(counterName, (IntPtr)nextPtr);
nextPtr += (counterName.Length + 1) * 2;
SetValue(newCounterEntryPointer, 0);
if (i != 0)
previousCounterEntryPointer->NextCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
previousCounterEntryPointer = newCounterEntryPointer;
newCounterEntryPointer++;
}
}
Debug.Assert(nextPtr - _baseAddress == freeMemoryOffset + totalSize, "We should have used all of the space we requested at this point");
int offset = (int)((long)newInstanceEntryPointer - _baseAddress);
categoryPointer->IsConsistent = 0;
// prepend the new instance rather than append, helps with perf of hooking up subsequent counters
newInstanceEntryPointer->NextInstanceOffset = categoryPointer->FirstInstanceOffset;
categoryPointer->FirstInstanceOffset = offset;
if (_categoryData.UseUniqueSharedMemory)
{
*((int*)_baseAddress) = newOffset;
categoryPointer->IsConsistent = 1;
}
return freeMemoryOffset;
}
private unsafe int CreateCounter(CounterEntry* lastCounterPointer,
int counterNameHashCode, string counterName)
{
int counterNameLength = (counterName.Length + 1) * 2;
int totalSize = sizeof(CounterEntry) + counterNameLength;
int alignmentAdjustment;
int freeMemoryOffset;
Debug.Assert(!_categoryData.UseUniqueSharedMemory, "We should never be calling CreateCounter in the unique shared memory");
freeMemoryOffset = CalculateAndAllocateMemory(totalSize, out alignmentAdjustment);
freeMemoryOffset += alignmentAdjustment;
long nextPtr = ResolveOffset(freeMemoryOffset, totalSize);
CounterEntry* newCounterEntryPointer = (CounterEntry*)nextPtr;
nextPtr += sizeof(CounterEntry);
newCounterEntryPointer->CounterNameOffset = (int)(nextPtr - _baseAddress);
newCounterEntryPointer->CounterNameHashCode = counterNameHashCode;
newCounterEntryPointer->NextCounterOffset = 0;
SetValue(newCounterEntryPointer, 0);
SafeMarshalCopy(counterName, (IntPtr)nextPtr);
Debug.Assert(nextPtr + counterNameLength - _baseAddress == freeMemoryOffset + totalSize, "We should have used all of the space we requested at this point");
lastCounterPointer->NextCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
return freeMemoryOffset;
}
private static unsafe void PopulateLifetimeEntry(ProcessLifetimeEntry* lifetimeEntry, PerformanceCounterInstanceLifetime lifetime)
{
if (lifetime == PerformanceCounterInstanceLifetime.Process)
{
lifetimeEntry->LifetimeType = (int)PerformanceCounterInstanceLifetime.Process;
lifetimeEntry->ProcessId = ProcessData.ProcessId;
lifetimeEntry->StartupTime = ProcessData.StartupTime;
}
else
{
lifetimeEntry->ProcessId = 0;
lifetimeEntry->StartupTime = 0;
}
}
private static unsafe void WaitAndEnterCriticalSection(int* spinLockPointer, out bool taken)
{
WaitForCriticalSection(spinLockPointer);
// Note - we are taking a lock here, but it probably isn't
// worthwhile to use Thread.BeginCriticalRegion & EndCriticalRegion.
// These only really help the CLR escalate from a thread abort
// to an appdomain unload, under the assumption that you may be
// editing shared state within the appdomain. Here you are editing
// shared state, but it is shared across processes. Unloading the
// appdomain isn't exactly helping. The only thing that would help
// would be if the CLR tells the host to ensure all allocations
// have a higher chance of succeeding within this critical region,
// but of course that's only a probabilisitic statement.
// Must be able to assign to the out param.
try
{
}
finally
{
int r = Interlocked.CompareExchange(ref *spinLockPointer, 1, 0);
taken = (r == 0);
}
}
private static unsafe void WaitForCriticalSection(int* spinLockPointer)
{
int spinCount = MaxSpinCount;
for (; spinCount > 0 && *spinLockPointer != 0; spinCount--)
{
// We suspect there are scenarios where the finalizer thread
// will call this method. The finalizer thread runs with
// a higher priority than the other code. Using SpinWait
// isn't sufficient, since it only spins, but doesn't yield
// to any lower-priority threads. Call Thread.Sleep(1).
if (*spinLockPointer != 0)
Thread.Sleep(1);
}
// if the lock still isn't free, most likely there's a deadlock caused by a process
// getting killed while it held the lock. We'll just free the lock
if (spinCount == 0 && *spinLockPointer != 0)
*spinLockPointer = 0;
}
private static unsafe void ExitCriticalSection(int* spinLockPointer)
{
*spinLockPointer = 0;
}
// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
// This hashcode function is identical to the one in SharedPerformanceCounter.cpp. If
// you change one without changing the other, perfcounters will break.
internal static int GetWstrHashCode(string wstr)
{
uint hash = 5381;
for (uint i = 0; i < wstr.Length; i++)
hash = ((hash << 5) + hash) ^ wstr[(int)i];
return (int)hash;
}
// Calculate the length of a string in the shared memory. If we reach the end of the shared memory
// before we see a null terminator, we throw.
private unsafe int GetStringLength(char* startChar)
{
char* currentChar = startChar;
ulong endAddress = (ulong)(_baseAddress + FileView._fileMappingSize);
while ((ulong)currentChar < (endAddress - 2))
{
if (*currentChar == 0)
return (int)(currentChar - startChar);
currentChar++;
}
throw new InvalidOperationException(SR.MappingCorrupted);
}
// Compare a managed string to a string located at a given offset. If we walk past the end of the
// shared memory, we throw.
private unsafe bool StringEquals(string stringA, int offset)
{
char* currentChar = (char*)ResolveOffset(offset, 0);
ulong endAddress = (ulong)(_baseAddress + FileView._fileMappingSize);
int i;
for (i = 0; i < stringA.Length; i++)
{
if ((ulong)(currentChar + i) > (endAddress - 2))
throw new InvalidOperationException(SR.MappingCorrupted);
if (stringA[i] != currentChar[i])
return false;
}
// now check for the null termination.
if ((ulong)(currentChar + i) > (endAddress - 2))
throw new InvalidOperationException(SR.MappingCorrupted);
return (currentChar[i] == 0);
}
private unsafe CategoryData GetCategoryData()
{
CategoryData data = (CategoryData)s_categoryDataTable[_categoryName];
if (data == null)
{
lock (s_categoryDataTable)
{
data = (CategoryData)s_categoryDataTable[_categoryName];
if (data == null)
{
data = new CategoryData();
data.FileMappingName = DefaultFileMappingName;
data.MutexName = _categoryName;
RegistryKey categoryKey = null;
try
{
categoryKey = Registry.LocalMachine.OpenSubKey(PerformanceCounterLib.ServicePath + "\\" + _categoryName + "\\Performance");
// first read the options
object optionsObject = categoryKey.GetValue("CategoryOptions");
if (optionsObject != null)
{
int options = (int)optionsObject;
data.EnableReuse = (((PerformanceCounterCategoryOptions)options & PerformanceCounterCategoryOptions.EnableReuse) != 0);
if (((PerformanceCounterCategoryOptions)options & PerformanceCounterCategoryOptions.UseUniqueSharedMemory) != 0)
{
data.UseUniqueSharedMemory = true;
_initialOffset = 8;
data.FileMappingName = DefaultFileMappingName + _categoryName;
}
}
int fileMappingSize;
object fileMappingSizeObject = categoryKey.GetValue("FileMappingSize");
if (fileMappingSizeObject != null && data.UseUniqueSharedMemory)
{
// we only use this reg value in the unique shared memory case.
fileMappingSize = (int)fileMappingSizeObject;
if (fileMappingSize < MinCountersFileMappingSize)
fileMappingSize = MinCountersFileMappingSize;
if (fileMappingSize > MaxCountersFileMappingSize)
fileMappingSize = MaxCountersFileMappingSize;
}
else
{
fileMappingSize = GetFileMappingSizeFromConfig();
if (data.UseUniqueSharedMemory)
fileMappingSize = fileMappingSize >> 2; // if we have a custom filemapping, only make it 25% as large.
}
// now read the counter names
object counterNamesObject = categoryKey.GetValue("Counter Names");
byte[] counterNamesBytes = counterNamesObject as byte[];
if (counterNamesBytes != null)
{
ArrayList names = new ArrayList();
fixed (byte* counterNamesPtr = counterNamesBytes)
{
int start = 0;
for (int i = 0; i < counterNamesBytes.Length - 1; i += 2)
{
if (counterNamesBytes[i] == 0 && counterNamesBytes[i + 1] == 0 && start != i)
{
string counter = new string((sbyte*)counterNamesPtr, start, i - start, Encoding.Unicode);
names.Add(counter.ToLowerInvariant());
start = i + 2;
}
}
}
data.CounterNames = names;
}
else
{
Debug.Assert(counterNamesObject is string[], $"Expected string[], got '{counterNamesObject}' of type '{counterNamesObject?.GetType()}' with kind '{categoryKey.GetValueKind("Counter Names")}' for category '{_categoryName}'");
string[] counterNames = (string[])counterNamesObject;
for (int i = 0; i < counterNames.Length; i++)
counterNames[i] = counterNames[i].ToLowerInvariant();
data.CounterNames = new ArrayList(counterNames);
}
data.FileMappingName = "Global\\" + data.FileMappingName;
data.MutexName = "Global\\" + _categoryName;
data.FileMapping = new FileMapping(data.FileMappingName, fileMappingSize, _initialOffset);
s_categoryDataTable[_categoryName] = data;
}
finally
{
if (categoryKey != null)
categoryKey.Close();
}
}
}
}
_baseAddress = (long)data.FileMapping.FileViewAddress;
if (data.UseUniqueSharedMemory)
_initialOffset = 8;
return data;
}
[MethodImpl(MethodImplOptions.NoInlining)]
private static int GetFileMappingSizeFromConfig()
{
return DiagnosticsConfiguration.PerformanceCountersFileMappingSize;
}
private static void RemoveCategoryData(string categoryName)
{
lock (s_categoryDataTable)
{
s_categoryDataTable.Remove(categoryName);
}
}
private unsafe CounterEntry* GetCounter(string counterName, string instanceName, bool enableReuse, PerformanceCounterInstanceLifetime lifetime)
{
int counterNameHashCode = GetWstrHashCode(counterName);
int instanceNameHashCode;
if (instanceName != null && instanceName.Length != 0)
instanceNameHashCode = GetWstrHashCode(instanceName);
else
{
instanceNameHashCode = s_singleInstanceHashCode;
instanceName = SingleInstanceName;
}
Mutex mutex = null;
CounterEntry* counterPointer = null;
InstanceEntry* instancePointer = null;
try
{
NetFrameworkUtils.EnterMutexWithoutGlobal(_categoryData.MutexName, ref mutex);
CategoryEntry* categoryPointer;
bool counterFound = false;
while (!FindCategory(&categoryPointer))
{
// don't bother locking again if we're using a separate shared memory.
bool sectionEntered;
if (_categoryData.UseUniqueSharedMemory)
sectionEntered = true;
else
WaitAndEnterCriticalSection(&(categoryPointer->SpinLock), out sectionEntered);
int newCategoryOffset;
if (sectionEntered)
{
try
{
newCategoryOffset = CreateCategory(categoryPointer, instanceNameHashCode, instanceName, lifetime);
}
finally
{
if (!_categoryData.UseUniqueSharedMemory)
ExitCriticalSection(&(categoryPointer->SpinLock));
}
categoryPointer = (CategoryEntry*)(ResolveOffset(newCategoryOffset, s_categoryEntrySize));
instancePointer = (InstanceEntry*)(ResolveOffset(categoryPointer->FirstInstanceOffset, s_instanceEntrySize));
counterFound = FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer);
Debug.Assert(counterFound, "All counters should be created, so we should always find the counter");
return counterPointer;
}
}
bool foundFreeInstance;
while (!FindInstance(instanceNameHashCode, instanceName, categoryPointer, &instancePointer, true, lifetime, out foundFreeInstance))
{
InstanceEntry* lockInstancePointer = instancePointer;
// don't bother locking again if we're using a separate shared memory.
bool sectionEntered;
if (_categoryData.UseUniqueSharedMemory)
sectionEntered = true;
else
WaitAndEnterCriticalSection(&(lockInstancePointer->SpinLock), out sectionEntered);
if (sectionEntered)
{
try
{
bool reused = false;
if (enableReuse && foundFreeInstance)
{
reused = TryReuseInstance(instanceNameHashCode, instanceName, categoryPointer, &instancePointer, lifetime, lockInstancePointer);
// at this point we might have reused an instance that came from v1.1/v1.0. We can't assume it will have the counter
// we're looking for.
}
if (!reused)
{
int newInstanceOffset = CreateInstance(categoryPointer, instanceNameHashCode, instanceName, lifetime);
instancePointer = (InstanceEntry*)(ResolveOffset(newInstanceOffset, s_instanceEntrySize));
counterFound = FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer);
Debug.Assert(counterFound, "All counters should be created, so we should always find the counter");
return counterPointer;
}
}
finally
{
if (!_categoryData.UseUniqueSharedMemory)
ExitCriticalSection(&(lockInstancePointer->SpinLock));
}
}
}
if (_categoryData.UseUniqueSharedMemory)
{
counterFound = FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer);
Debug.Assert(counterFound, "All counters should be created, so we should always find the counter");
return counterPointer;
}
else
{
while (!FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer))
{
bool sectionEntered;
WaitAndEnterCriticalSection(&(counterPointer->SpinLock), out sectionEntered);
if (sectionEntered)
{
try
{
int newCounterOffset = CreateCounter(counterPointer, counterNameHashCode, counterName);
return (CounterEntry*)(ResolveOffset(newCounterOffset, s_counterEntrySize));
}
finally
{
ExitCriticalSection(&(counterPointer->SpinLock));
}
}
}
return counterPointer;
}
}
finally
{
// cache this instance for reuse
try
{
if (counterPointer != null && instancePointer != null)
{
_thisInstanceOffset = ResolveAddress((long)instancePointer, s_instanceEntrySize);
}
}
catch (InvalidOperationException)
{
_thisInstanceOffset = -1;
}
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
//
// FindCategory -
//
// * when the function returns true the returnCategoryPointerReference is set to the CategoryEntry
// that matches 'categoryNameHashCode' and 'categoryName'
//
// * when the function returns false the returnCategoryPointerReference is set to the last CategoryEntry
// in the linked list
//
private unsafe bool FindCategory(CategoryEntry** returnCategoryPointerReference)
{
CategoryEntry* firstCategoryPointer = (CategoryEntry*)(ResolveOffset(_initialOffset, s_categoryEntrySize));
CategoryEntry* currentCategoryPointer = firstCategoryPointer;
CategoryEntry* previousCategoryPointer = firstCategoryPointer;
while (true)
{
if (currentCategoryPointer->IsConsistent == 0)
Verify(currentCategoryPointer);
if (currentCategoryPointer->CategoryNameHashCode == _categoryNameHashCode)
{
if (StringEquals(_categoryName, currentCategoryPointer->CategoryNameOffset))
{
*returnCategoryPointerReference = currentCategoryPointer;
return true;
}
}
previousCategoryPointer = currentCategoryPointer;
if (currentCategoryPointer->NextCategoryOffset != 0)
currentCategoryPointer = (CategoryEntry*)(ResolveOffset(currentCategoryPointer->NextCategoryOffset, s_categoryEntrySize));
else
{
*returnCategoryPointerReference = previousCategoryPointer;
return false;
}
}
}
private unsafe bool FindCounter(int counterNameHashCode, string counterName, InstanceEntry* instancePointer, CounterEntry** returnCounterPointerReference)
{
CounterEntry* currentCounterPointer = (CounterEntry*)(ResolveOffset(instancePointer->FirstCounterOffset, s_counterEntrySize));
CounterEntry* previousCounterPointer = currentCounterPointer;
while (true)
{
if (currentCounterPointer->CounterNameHashCode == counterNameHashCode)
{
if (StringEquals(counterName, currentCounterPointer->CounterNameOffset))
{
*returnCounterPointerReference = currentCounterPointer;
return true;
}
}
previousCounterPointer = currentCounterPointer;
if (currentCounterPointer->NextCounterOffset != 0)
currentCounterPointer = (CounterEntry*)(ResolveOffset(currentCounterPointer->NextCounterOffset, s_counterEntrySize));
else
{
*returnCounterPointerReference = previousCounterPointer;
return false;
}
}
}
private unsafe bool FindInstance(int instanceNameHashCode, string instanceName,
CategoryEntry* categoryPointer, InstanceEntry** returnInstancePointerReference,
bool activateUnusedInstances, PerformanceCounterInstanceLifetime lifetime,
out bool foundFreeInstance)
{
InstanceEntry* currentInstancePointer = (InstanceEntry*)(ResolveOffset(categoryPointer->FirstInstanceOffset, s_instanceEntrySize));
InstanceEntry* previousInstancePointer = currentInstancePointer;
foundFreeInstance = false;
// Look at the first instance to determine if this is single or multi instance.
if (currentInstancePointer->InstanceNameHashCode == s_singleInstanceHashCode)
{
if (StringEquals(SingleInstanceName, currentInstancePointer->InstanceNameOffset))
{
if (instanceName != SingleInstanceName)
throw new InvalidOperationException(SR.Format(SR.SingleInstanceOnly, _categoryName));
}
else
{
if (instanceName == SingleInstanceName)
throw new InvalidOperationException(SR.Format(SR.MultiInstanceOnly, _categoryName));
}
}
else
{
if (instanceName == SingleInstanceName)
throw new InvalidOperationException(SR.Format(SR.MultiInstanceOnly, _categoryName));
}
//
// 1st pass find exact matching!
//
// We don't need to aggressively claim unused instances. For performance, we would proactively
// verify lifetime of instances if activateUnusedInstances is specified and certain time
// has elapsed since last sweep or we are running out of shared memory.
bool verifyLifeTime = activateUnusedInstances;
if (activateUnusedInstances)
{
int totalSize = s_instanceEntrySize + s_processLifetimeEntrySize + InstanceNameSlotSize + (s_counterEntrySize * _categoryData.CounterNames.Count);
int freeMemoryOffset = *((int*)_baseAddress);
int alignmentAdjustment;
int newOffset = CalculateMemoryNoBoundsCheck(freeMemoryOffset, totalSize, out alignmentAdjustment);
if (!(newOffset > FileView._fileMappingSize || newOffset < 0))
{
long tickDelta = (DateTime.Now.Ticks - Volatile.Read(ref s_lastInstanceLifetimeSweepTick));
if (tickDelta < InstanceLifetimeSweepWindow)
verifyLifeTime = false;
}
}
try
{
while (true)
{
bool verifiedLifetimeOfThisInstance = false;
if (verifyLifeTime && (currentInstancePointer->RefCount != 0))
{
verifiedLifetimeOfThisInstance = true;
VerifyLifetime(currentInstancePointer);
}
if (currentInstancePointer->InstanceNameHashCode == instanceNameHashCode)
{
if (StringEquals(instanceName, currentInstancePointer->InstanceNameOffset))
{
// we found a matching instance.
*returnInstancePointerReference = currentInstancePointer;
CounterEntry* firstCounter = (CounterEntry*)ResolveOffset(currentInstancePointer->FirstCounterOffset, s_counterEntrySize);
ProcessLifetimeEntry* lifetimeEntry;
if (_categoryData.UseUniqueSharedMemory)
lifetimeEntry = (ProcessLifetimeEntry*)ResolveOffset(firstCounter->LifetimeOffset, s_processLifetimeEntrySize);
else
lifetimeEntry = null;
// ensure that we have verified the lifetime of the matched instance
if (!verifiedLifetimeOfThisInstance && currentInstancePointer->RefCount != 0)
VerifyLifetime(currentInstancePointer);
if (currentInstancePointer->RefCount != 0)
{
if (lifetimeEntry != null && lifetimeEntry->ProcessId != 0)
{
if (lifetime != PerformanceCounterInstanceLifetime.Process)
throw new InvalidOperationException(SR.CantConvertProcessToGlobal);
// make sure only one process is using this instance.
if (ProcessData.ProcessId != lifetimeEntry->ProcessId)
throw new InvalidOperationException(SR.Format(SR.InstanceAlreadyExists, instanceName));
// compare start time of the process, account for ACL issues in querying process information
if ((lifetimeEntry->StartupTime != -1) && (ProcessData.StartupTime != -1))
{
if (ProcessData.StartupTime != lifetimeEntry->StartupTime)
throw new InvalidOperationException(SR.Format(SR.InstanceAlreadyExists, instanceName));
}
}
else
{
if (lifetime == PerformanceCounterInstanceLifetime.Process)
throw new InvalidOperationException(SR.CantConvertGlobalToProcess);
}
return true;
}
if (activateUnusedInstances)
{
Mutex mutex = null;
try
{
NetFrameworkUtils.EnterMutexWithoutGlobal(_categoryData.MutexName, ref mutex);
ClearCounterValues(currentInstancePointer);
if (lifetimeEntry != null)
PopulateLifetimeEntry(lifetimeEntry, lifetime);
currentInstancePointer->RefCount = 1;
return true;
}
finally
{
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
else
return false;
}
}
if (currentInstancePointer->RefCount == 0)
{
foundFreeInstance = true;
}
previousInstancePointer = currentInstancePointer;
if (currentInstancePointer->NextInstanceOffset != 0)
currentInstancePointer = (InstanceEntry*)(ResolveOffset(currentInstancePointer->NextInstanceOffset, s_instanceEntrySize));
else
{
*returnInstancePointerReference = previousInstancePointer;
return false;
}
}
}
finally
{
if (verifyLifeTime)
Volatile.Write(ref s_lastInstanceLifetimeSweepTick, DateTime.Now.Ticks);
}
}
private unsafe bool TryReuseInstance(int instanceNameHashCode, string instanceName,
CategoryEntry* categoryPointer, InstanceEntry** returnInstancePointerReference,
PerformanceCounterInstanceLifetime lifetime,
InstanceEntry* lockInstancePointer)
{
// 2nd pass find a free instance slot
InstanceEntry* currentInstancePointer = (InstanceEntry*)(ResolveOffset(categoryPointer->FirstInstanceOffset, s_instanceEntrySize));
InstanceEntry* previousInstancePointer = currentInstancePointer;
while (true)
{
if (currentInstancePointer->RefCount == 0)
{
bool hasFit;
long instanceNamePtr; // we need cache this to avoid race conditions.
if (_categoryData.UseUniqueSharedMemory)
{
instanceNamePtr = ResolveOffset(currentInstancePointer->InstanceNameOffset, InstanceNameSlotSize);
// In the separate shared memory case we should always have enough space for instances. The
// name slot size is fixed.
Debug.Assert(((instanceName.Length + 1) * 2) <= InstanceNameSlotSize, "The instance name length should always fit in our slot size");
hasFit = true;
}
else
{
// we don't know the string length yet.
instanceNamePtr = ResolveOffset(currentInstancePointer->InstanceNameOffset, 0);
// In the global shared memory, we require names to be exactly the same length in order
// to reuse them. This way we don't end up leaking any space and we don't need to
// depend on the layout of the memory to calculate the space we have.
int length = GetStringLength((char*)instanceNamePtr);
hasFit = (length == instanceName.Length);
}
bool noSpinLock = (lockInstancePointer == currentInstancePointer) || _categoryData.UseUniqueSharedMemory;
// Instance name fit
if (hasFit)
{
// don't bother locking again if we're using a separate shared memory.
bool sectionEntered;
if (noSpinLock)
sectionEntered = true;
else
WaitAndEnterCriticalSection(&(currentInstancePointer->SpinLock), out sectionEntered);
if (sectionEntered)
{
try
{
// Make copy with zero-term
SafeMarshalCopy(instanceName, (IntPtr)instanceNamePtr);
currentInstancePointer->InstanceNameHashCode = instanceNameHashCode;
// return
*returnInstancePointerReference = currentInstancePointer;
// clear the counter values.
ClearCounterValues(*returnInstancePointerReference);
if (_categoryData.UseUniqueSharedMemory)
{
CounterEntry* counterPointer = (CounterEntry*)ResolveOffset(currentInstancePointer->FirstCounterOffset, s_counterEntrySize);
ProcessLifetimeEntry* lifetimeEntry = (ProcessLifetimeEntry*)ResolveOffset(counterPointer->LifetimeOffset, s_processLifetimeEntrySize);
PopulateLifetimeEntry(lifetimeEntry, lifetime);
}
(*returnInstancePointerReference)->RefCount = 1;
return true;
}
finally
{
if (!noSpinLock)
ExitCriticalSection(&(currentInstancePointer->SpinLock));
}
}
}
}
previousInstancePointer = currentInstancePointer;
if (currentInstancePointer->NextInstanceOffset != 0)
currentInstancePointer = (InstanceEntry*)(ResolveOffset(currentInstancePointer->NextInstanceOffset, s_instanceEntrySize));
else
{
*returnInstancePointerReference = previousInstancePointer;
return false;
}
}
}
private unsafe void Verify(CategoryEntry* currentCategoryPointer)
{
if (!_categoryData.UseUniqueSharedMemory)
return;
Mutex mutex = null;
try
{
NetFrameworkUtils.EnterMutexWithoutGlobal(_categoryData.MutexName, ref mutex);
VerifyCategory(currentCategoryPointer);
}
finally
{
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
private unsafe void VerifyCategory(CategoryEntry* currentCategoryPointer)
{
int freeOffset = *((int*)_baseAddress);
ResolveOffset(freeOffset, 0); // verify next free offset
// begin by verifying the head node's offset
int currentOffset = ResolveAddress((long)currentCategoryPointer, s_categoryEntrySize);
if (currentOffset >= freeOffset)
{
// zero out the bad head node entry
currentCategoryPointer->SpinLock = 0;
currentCategoryPointer->CategoryNameHashCode = 0;
currentCategoryPointer->CategoryNameOffset = 0;
currentCategoryPointer->FirstInstanceOffset = 0;
currentCategoryPointer->NextCategoryOffset = 0;
currentCategoryPointer->IsConsistent = 0;
return;
}
if (currentCategoryPointer->NextCategoryOffset > freeOffset)
currentCategoryPointer->NextCategoryOffset = 0;
else if (currentCategoryPointer->NextCategoryOffset != 0)
VerifyCategory((CategoryEntry*)ResolveOffset(currentCategoryPointer->NextCategoryOffset, s_categoryEntrySize));
if (currentCategoryPointer->FirstInstanceOffset != 0)
{
// Check whether the recently added instance at the head of the list is committed. If not, rewire
// the head of the list to point to the next instance
if (currentCategoryPointer->FirstInstanceOffset > freeOffset)
{
InstanceEntry* currentInstancePointer = (InstanceEntry*)ResolveOffset(currentCategoryPointer->FirstInstanceOffset, s_instanceEntrySize);
currentCategoryPointer->FirstInstanceOffset = currentInstancePointer->NextInstanceOffset;
if (currentCategoryPointer->FirstInstanceOffset > freeOffset)
currentCategoryPointer->FirstInstanceOffset = 0;
}
if (currentCategoryPointer->FirstInstanceOffset != 0)
{
Debug.Assert(currentCategoryPointer->FirstInstanceOffset <= freeOffset, "The head of the list is inconsistent - possible mismatch of V2 & V3 instances?");
VerifyInstance((InstanceEntry*)ResolveOffset(currentCategoryPointer->FirstInstanceOffset, s_instanceEntrySize));
}
}
currentCategoryPointer->IsConsistent = 1;
}
private unsafe void VerifyInstance(InstanceEntry* currentInstancePointer)
{
int freeOffset = *((int*)_baseAddress);
ResolveOffset(freeOffset, 0); // verify next free offset
if (currentInstancePointer->NextInstanceOffset > freeOffset)
currentInstancePointer->NextInstanceOffset = 0;
else if (currentInstancePointer->NextInstanceOffset != 0)
VerifyInstance((InstanceEntry*)ResolveOffset(currentInstancePointer->NextInstanceOffset, s_instanceEntrySize));
}
private unsafe void VerifyLifetime(InstanceEntry* currentInstancePointer)
{
Debug.Assert(currentInstancePointer->RefCount != 0, "RefCount must be 1 for instances passed to VerifyLifetime");
CounterEntry* counter = (CounterEntry*)ResolveOffset(currentInstancePointer->FirstCounterOffset, s_counterEntrySize);
if (counter->LifetimeOffset != 0)
{
ProcessLifetimeEntry* lifetime = (ProcessLifetimeEntry*)ResolveOffset(counter->LifetimeOffset, s_processLifetimeEntrySize);
if (lifetime->LifetimeType == (int)PerformanceCounterInstanceLifetime.Process)
{
int pid = lifetime->ProcessId;
long startTime = lifetime->StartupTime;
if (pid != 0)
{
// Optimize for this process
if (pid == ProcessData.ProcessId)
{
if ((ProcessData.StartupTime != -1) && (startTime != -1) && (ProcessData.StartupTime != startTime))
{
// Process id got recycled. Reclaim this instance.
currentInstancePointer->RefCount = 0;
return;
}
}
else
{
long processStartTime;
using (SafeProcessHandle procHandle = Interop.Kernel32.OpenProcess(Interop.Advapi32.ProcessOptions.PROCESS_QUERY_INFORMATION, false, pid))
{
int error = Marshal.GetLastWin32Error();
if ((error == Interop.Errors.ERROR_INVALID_PARAMETER) && procHandle.IsInvalid)
{
// The process is dead. Reclaim this instance. Note that we only clear the refcount here.
// If we tried to clear the pid and startup time as well, we would have a race where
// we could clear the pid/startup time but not the refcount.
currentInstancePointer->RefCount = 0;
return;
}
// Defer cleaning the instance when we had previously encountered errors in
// recording process start time (i.e, when startTime == -1) until after the
// process id is not valid (which will be caught in the if check above)
if (!procHandle.IsInvalid && startTime != -1)
{
long temp;
if (Interop.Kernel32.GetProcessTimes(procHandle, out processStartTime, out temp, out temp, out temp))
{
if (processStartTime != startTime)
{
// The process is dead but a new one is using the same pid. Reclaim this instance.
currentInstancePointer->RefCount = 0;
return;
}
}
}
}
// Check to see if the process handle has been signaled by the kernel. If this is the case then it's safe
// to reclaim the instance as the process is in the process of exiting.
using (SafeProcessHandle procHandle = Interop.Kernel32.OpenProcess(Interop.Advapi32.ProcessOptions.SYNCHRONIZE, false, pid))
{
if (!procHandle.IsInvalid)
{
using (Interop.Kernel32.ProcessWaitHandle wh = new Interop.Kernel32.ProcessWaitHandle(procHandle))
{
if (wh.WaitOne(0, false))
{
// Process has exited
currentInstancePointer->RefCount = 0;
return;
}
}
}
}
}
}
}
}
}
internal unsafe long IncrementBy(long value)
{
if (_counterEntryPointer == null)
return 0;
CounterEntry* counterEntry = _counterEntryPointer;
return AddToValue(counterEntry, value);
}
internal unsafe long Increment()
{
if (_counterEntryPointer == null)
return 0;
return IncrementUnaligned(_counterEntryPointer);
}
internal unsafe long Decrement()
{
if (_counterEntryPointer == null)
return 0;
return DecrementUnaligned(_counterEntryPointer);
}
internal static unsafe void RemoveAllInstances(string categoryName)
{
SharedPerformanceCounter spc = new SharedPerformanceCounter(categoryName, null, null);
spc.RemoveAllInstances();
RemoveCategoryData(categoryName);
}
private unsafe void RemoveAllInstances()
{
CategoryEntry* categoryPointer;
if (!FindCategory(&categoryPointer))
return;
InstanceEntry* instancePointer = (InstanceEntry*)(ResolveOffset(categoryPointer->FirstInstanceOffset, s_instanceEntrySize));
Mutex mutex = null;
try
{
NetFrameworkUtils.EnterMutexWithoutGlobal(_categoryData.MutexName, ref mutex);
while (true)
{
RemoveOneInstance(instancePointer, true);
if (instancePointer->NextInstanceOffset != 0)
instancePointer = (InstanceEntry*)(ResolveOffset(instancePointer->NextInstanceOffset, s_instanceEntrySize));
else
{
break;
}
}
}
finally
{
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
internal unsafe void RemoveInstance(string instanceName, PerformanceCounterInstanceLifetime instanceLifetime)
{
if (instanceName == null || instanceName.Length == 0)
return;
int instanceNameHashCode = GetWstrHashCode(instanceName);
CategoryEntry* categoryPointer;
if (!FindCategory(&categoryPointer))
return;
InstanceEntry* instancePointer = null;
bool validatedCachedInstancePointer = false;
bool temp;
Mutex mutex = null;
try
{
NetFrameworkUtils.EnterMutexWithoutGlobal(_categoryData.MutexName, ref mutex);
if (_thisInstanceOffset != -1)
{
try
{
// validate whether the cached instance pointer is pointing at the right instance
instancePointer = (InstanceEntry*)(ResolveOffset(_thisInstanceOffset, s_instanceEntrySize));
if (instancePointer->InstanceNameHashCode == instanceNameHashCode)
{
if (StringEquals(instanceName, instancePointer->InstanceNameOffset))
{
validatedCachedInstancePointer = true;
CounterEntry* firstCounter = (CounterEntry*)ResolveOffset(instancePointer->FirstCounterOffset, s_counterEntrySize);
ProcessLifetimeEntry* lifetimeEntry;
if (_categoryData.UseUniqueSharedMemory)
{
lifetimeEntry = (ProcessLifetimeEntry*)ResolveOffset(firstCounter->LifetimeOffset, s_processLifetimeEntrySize);
if (lifetimeEntry != null
&& lifetimeEntry->LifetimeType == (int)PerformanceCounterInstanceLifetime.Process
&& lifetimeEntry->ProcessId != 0)
{
validatedCachedInstancePointer &= (instanceLifetime == PerformanceCounterInstanceLifetime.Process);
validatedCachedInstancePointer &= (ProcessData.ProcessId == lifetimeEntry->ProcessId);
if ((lifetimeEntry->StartupTime != -1) && (ProcessData.StartupTime != -1))
validatedCachedInstancePointer &= (ProcessData.StartupTime == lifetimeEntry->StartupTime);
}
else
validatedCachedInstancePointer &= (instanceLifetime != PerformanceCounterInstanceLifetime.Process);
}
}
}
}
catch (InvalidOperationException)
{
validatedCachedInstancePointer = false;
}
if (!validatedCachedInstancePointer)
_thisInstanceOffset = -1;
}
if (!validatedCachedInstancePointer && !FindInstance(instanceNameHashCode, instanceName, categoryPointer, &instancePointer, false, instanceLifetime, out temp))
return;
if (instancePointer != null)
RemoveOneInstance(instancePointer, false);
}
finally
{
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
private unsafe void RemoveOneInstance(InstanceEntry* instancePointer, bool clearValue)
{
bool sectionEntered = false;
try
{
if (!_categoryData.UseUniqueSharedMemory)
{
while (!sectionEntered)
{
WaitAndEnterCriticalSection(&(instancePointer->SpinLock), out sectionEntered);
}
}
instancePointer->RefCount = 0;
if (clearValue)
ClearCounterValues(instancePointer);
}
finally
{
if (sectionEntered)
ExitCriticalSection(&(instancePointer->SpinLock));
}
}
private unsafe void ClearCounterValues(InstanceEntry* instancePointer)
{
//Clear counter instance values
CounterEntry* currentCounterPointer = null;
if (instancePointer->FirstCounterOffset != 0)
currentCounterPointer = (CounterEntry*)(ResolveOffset(instancePointer->FirstCounterOffset, s_counterEntrySize));
while (currentCounterPointer != null)
{
SetValue(currentCounterPointer, 0);
if (currentCounterPointer->NextCounterOffset != 0)
currentCounterPointer = (CounterEntry*)(ResolveOffset(currentCounterPointer->NextCounterOffset, s_counterEntrySize));
else
currentCounterPointer = null;
}
}
private static unsafe long AddToValue(CounterEntry* counterEntry, long addend)
{
// Called while holding a lock - shouldn't have to worry about
// reading misaligned data & getting old vs. new parts of an Int64.
if (IsMisaligned(counterEntry))
{
ulong newvalue;
CounterEntryMisaligned* entry = (CounterEntryMisaligned*)counterEntry;
newvalue = (uint)entry->Value_hi;
newvalue <<= 32;
newvalue |= (uint)entry->Value_lo;
newvalue = (ulong)((long)newvalue + addend);
entry->Value_hi = (int)(newvalue >> 32);
entry->Value_lo = (int)(newvalue & 0xffffffff);
return (long)newvalue;
}
else
return Interlocked.Add(ref counterEntry->Value, addend);
}
private static unsafe long DecrementUnaligned(CounterEntry* counterEntry)
{
if (IsMisaligned(counterEntry))
return AddToValue(counterEntry, -1);
else
return Interlocked.Decrement(ref counterEntry->Value);
}
private static unsafe long GetValue(CounterEntry* counterEntry)
{
if (IsMisaligned(counterEntry))
{
ulong value;
CounterEntryMisaligned* entry = (CounterEntryMisaligned*)counterEntry;
value = (uint)entry->Value_hi;
value <<= 32;
value |= (uint)entry->Value_lo;
return (long)value;
}
else
return counterEntry->Value;
}
private static unsafe long IncrementUnaligned(CounterEntry* counterEntry)
{
if (IsMisaligned(counterEntry))
return AddToValue(counterEntry, 1);
else
return Interlocked.Increment(ref counterEntry->Value);
}
private static unsafe void SetValue(CounterEntry* counterEntry, long value)
{
if (IsMisaligned(counterEntry))
{
CounterEntryMisaligned* entry = (CounterEntryMisaligned*)counterEntry;
entry->Value_lo = (int)(value & 0xffffffff);
entry->Value_hi = (int)(value >> 32);
}
else
counterEntry->Value = value;
}
private static unsafe bool IsMisaligned(CounterEntry* counterEntry)
{
return (((long)counterEntry & 0x7) != 0);
}
private long ResolveOffset(int offset, int sizeToRead)
{
//It is very important to check the integrity of the shared memory
//everytime a new address is resolved.
if (offset > (FileView._fileMappingSize - sizeToRead) || offset < 0)
throw new InvalidOperationException(SR.MappingCorrupted);
long address = _baseAddress + offset;
return address;
}
private int ResolveAddress(long address, int sizeToRead)
{
int offset = (int)(address - _baseAddress);
//It is very important to check the integrity of the shared memory
//everytime a new address is resolved.
if (offset > (FileView._fileMappingSize - sizeToRead) || offset < 0)
throw new InvalidOperationException(SR.MappingCorrupted);
return offset;
}
private sealed class FileMapping
{
internal int _fileMappingSize;
private SafeMemoryMappedViewHandle _fileViewAddress;
private SafeMemoryMappedFileHandle _fileMappingHandle;
//The version of the file mapping name is independent from the
//assembly version.
public FileMapping(string fileMappingName, int fileMappingSize, int initialOffset)
{
Initialize(fileMappingName, fileMappingSize, initialOffset);
}
internal IntPtr FileViewAddress
{
get
{
if (_fileViewAddress.IsInvalid)
throw new InvalidOperationException(SR.SharedMemoryGhosted);
return _fileViewAddress.DangerousGetHandle();
}
}
private unsafe void Initialize(string fileMappingName, int fileMappingSize, int initialOffset)
{
string mappingName = fileMappingName;
SafeLocalAllocHandle securityDescriptorPointer = null;
try
{
// The sddl string consists of these parts:
// D: it's a DACL
// (A; this is an allow ACE
// OICI; object inherit and container inherit
// FRFWGRGW;;; allow file read, file write, generic read and generic write
// AU) granted to Authenticated Users
// ;S-1-5-33) the same permission granted to AU is also granted to restricted services
string sddlString = "D:(A;OICI;FRFWGRGW;;;AU)(A;OICI;FRFWGRGW;;;S-1-5-33)";
if (!Interop.Advapi32.ConvertStringSecurityDescriptorToSecurityDescriptor(sddlString, Interop.Kernel32.PerformanceCounterOptions.SDDL_REVISION_1,
out securityDescriptorPointer, IntPtr.Zero))
throw new InvalidOperationException(SR.SetSecurityDescriptorFailed);
Interop.Kernel32.SECURITY_ATTRIBUTES securityAttributes = default;
securityAttributes.lpSecurityDescriptor = securityDescriptorPointer.DangerousGetHandle();
securityAttributes.bInheritHandle = Interop.BOOL.FALSE;
//
//
// Here we call CreateFileMapping to create the memory mapped file. When CreateFileMapping fails
// with ERROR_ACCESS_DENIED, we know the file mapping has been created and we then open it with OpenFileMapping.
//
// There is chance of a race condition between CreateFileMapping and OpenFileMapping; The memory mapped file
// may actually be closed in between these two calls. When this happens, OpenFileMapping returns ERROR_FILE_NOT_FOUND.
// In this case, we need to loop back and retry creating the memory mapped file.
//
// This loop will timeout in approximately 1.4 minutes. An InvalidOperationException is thrown in the timeout case.
//
//
int waitRetries = 14; //((2^13)-1)*10ms == approximately 1.4mins
int waitSleep = 0;
bool created = false;
while (!created && waitRetries > 0)
{
_fileMappingHandle = Interop.Kernel32.CreateFileMapping((IntPtr)(-1), ref securityAttributes,
Interop.Kernel32.PageOptions.PAGE_READWRITE, 0, fileMappingSize, mappingName);
if ((Marshal.GetLastWin32Error() != Interop.Errors.ERROR_ACCESS_DENIED) || !_fileMappingHandle.IsInvalid)
{
created = true;
}
else
{
// Invalidate the old safehandle before we get rid of it. This prevents it from trying to finalize
_fileMappingHandle.SetHandleAsInvalid();
_fileMappingHandle = Interop.Kernel32.OpenFileMapping(Interop.Kernel32.FileMapOptions.FILE_MAP_WRITE, false, mappingName);
if ((Marshal.GetLastWin32Error() != Interop.Errors.ERROR_FILE_NOT_FOUND) || !_fileMappingHandle.IsInvalid)
{
created = true;
}
else
{
--waitRetries;
if (waitSleep == 0)
{
waitSleep = 10;
}
else
{
System.Threading.Thread.Sleep(waitSleep);
waitSleep *= 2;
}
}
}
}
if (_fileMappingHandle.IsInvalid)
{
throw new InvalidOperationException(SR.CantCreateFileMapping);
}
_fileViewAddress = Interop.Kernel32.MapViewOfFile(_fileMappingHandle, Interop.Kernel32.FileMapOptions.FILE_MAP_WRITE, 0, 0, UIntPtr.Zero);
if (_fileViewAddress.IsInvalid)
throw new InvalidOperationException(SR.CantMapFileView);
// figure out what size the share memory really is.
Interop.Kernel32.MEMORY_BASIC_INFORMATION meminfo = default;
if (Interop.Kernel32.VirtualQuery(_fileViewAddress, ref meminfo, (UIntPtr)sizeof(Interop.Kernel32.MEMORY_BASIC_INFORMATION)) == UIntPtr.Zero)
throw new InvalidOperationException(SR.CantGetMappingSize);
_fileMappingSize = (int)meminfo.RegionSize;
}
finally
{
if (securityDescriptorPointer != null)
securityDescriptorPointer.Close();
}
Interlocked.CompareExchange(ref *(int*)_fileViewAddress.DangerousGetHandle().ToPointer(), initialOffset, 0);
}
}
// SafeMarshalCopy always null terminates the char array
// before copying it to native memory
//
private static void SafeMarshalCopy(string str, IntPtr nativePointer)
{
// convert str to a char array and copy it to the unmanaged memory pointer
char[] tmp = new char[str.Length + 1];
str.CopyTo(0, tmp, 0, str.Length);
tmp[str.Length] = '\0'; // make sure the char[] is null terminated
Marshal.Copy(tmp, 0, nativePointer, tmp.Length);
}
// <WARNING>
// The final tmpPadding field is needed to make the size of this structure 8-byte aligned. This is
// necessary on IA64.
// </WARNING>
// Note that in V1.0 and v1.1 there was no explicit padding defined on any of these structs. That means that
// sizeof(CategoryEntry) or Marshal.SizeOf(typeof(CategoryEntry)) returned 4 bytes less before Whidbey,
// and the int we use as IsConsistent could actually overlap the InstanceEntry SpinLock.
[StructLayout(LayoutKind.Sequential)]
private struct CategoryEntry
{
public int SpinLock;
public int CategoryNameHashCode;
public int CategoryNameOffset;
public int FirstInstanceOffset;
public int NextCategoryOffset;
public int IsConsistent; // this was 4 bytes of padding in v1.0/v1.1
}
[StructLayout(LayoutKind.Sequential)]
private struct InstanceEntry
{
public int SpinLock;
public int InstanceNameHashCode;
public int InstanceNameOffset;
public int RefCount;
public int FirstCounterOffset;
public int NextInstanceOffset;
}
[StructLayout(LayoutKind.Sequential)]
private struct CounterEntry
{
public int SpinLock;
public int CounterNameHashCode;
public int CounterNameOffset;
public int LifetimeOffset; // this was 4 bytes of padding in v1.0/v1.1
public long Value;
public int NextCounterOffset;
public int padding2;
}
[StructLayout(LayoutKind.Sequential)]
private struct CounterEntryMisaligned
{
public int SpinLock;
public int CounterNameHashCode;
public int CounterNameOffset;
public int LifetimeOffset; // this was 4 bytes of padding in v1.0/v1.1
public int Value_lo;
public int Value_hi;
public int NextCounterOffset;
public int padding2; // The compiler adds this only if there is an int64 in the struct -
// ie only for CounterEntry. It really needs to be here.
}
[StructLayout(LayoutKind.Sequential)]
private struct ProcessLifetimeEntry
{
public int LifetimeType;
public int ProcessId;
public long StartupTime;
}
private sealed class CategoryData
{
public FileMapping FileMapping;
public bool EnableReuse;
public bool UseUniqueSharedMemory;
public string FileMappingName;
public string MutexName;
public ArrayList CounterNames;
}
}
internal sealed class ProcessData
{
public ProcessData(int pid, long startTime)
{
ProcessId = pid;
StartupTime = startTime;
}
public int ProcessId;
public long StartupTime;
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Text;
using System.Threading;
using System.Collections;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;
namespace System.Diagnostics
{
internal sealed class SharedPerformanceCounter
{
private const int MaxSpinCount = 5000;
internal const int DefaultCountersFileMappingSize = 524288;
internal const int MaxCountersFileMappingSize = 33554432;
internal const int MinCountersFileMappingSize = 32768;
internal const int InstanceNameMaxLength = 127;
internal const int InstanceNameSlotSize = 256;
internal const string SingleInstanceName = "systemdiagnosticssharedsingleinstance";
internal const string DefaultFileMappingName = "netfxcustomperfcounters.1.0";
internal static readonly int s_singleInstanceHashCode = GetWstrHashCode(SingleInstanceName);
private static readonly Hashtable s_categoryDataTable = new Hashtable(StringComparer.Ordinal);
private static readonly int s_categoryEntrySize = Marshal.SizeOf(typeof(CategoryEntry));
private static readonly int s_instanceEntrySize = Marshal.SizeOf(typeof(InstanceEntry));
private static readonly int s_counterEntrySize = Marshal.SizeOf(typeof(CounterEntry));
private static readonly int s_processLifetimeEntrySize = Marshal.SizeOf(typeof(ProcessLifetimeEntry));
private static long s_lastInstanceLifetimeSweepTick;
private const long InstanceLifetimeSweepWindow = 30 * 10000000; //ticks
private static volatile ProcessData s_procData;
private static ProcessData ProcessData
{
get
{
if (s_procData == null)
{
try
{
int pid = (int)Interop.Kernel32.GetCurrentProcessId();
long startTime = -1;
// Though we have asserted the required CAS permissions above, we may
// still fail to query the process information if the user does not
// have the necessary process access rights or privileges.
// This might be the case if the current process was started by a
// different user (primary token) than the current user
// (impersonation token) that has less privilege/ACL rights.
using (SafeProcessHandle procHandle = Interop.Kernel32.OpenProcess(Interop.Advapi32.ProcessOptions.PROCESS_QUERY_INFORMATION, false, pid))
{
if (!procHandle.IsInvalid)
{
long temp;
Interop.Kernel32.GetProcessTimes(procHandle, out startTime, out temp, out temp, out temp);
}
}
s_procData = new ProcessData(pid, startTime);
}
finally
{
}
}
return s_procData;
}
}
// InitialOffset is the offset in our global shared memory where we put the first CategoryEntry. It needs to be 4 because in
// v1.0 and v1.1 we used IntPtr.Size. That creates potential side-by-side issues on 64 bit machines using WOW64.
// A v1.0 app running on WOW64 will assume the InitialOffset is 4. A true 64 bit app on the same machine will assume
// the initial offset is 8.
// However, using an offset of 4 means that our CounterEntry.Value is potentially misaligned. This is why we have SetValue
// and other methods which split CounterEntry.Value into two ints. With separate shared memory blocks per
// category, we can fix this and always use an inital offset of 8.
internal int _initialOffset = 4;
private readonly CategoryData _categoryData;
private long _baseAddress;
private readonly unsafe CounterEntry* _counterEntryPointer;
private readonly string _categoryName;
private readonly int _categoryNameHashCode;
private int _thisInstanceOffset = -1;
internal SharedPerformanceCounter(string catName, string counterName, string instanceName) :
this(catName, counterName, instanceName, PerformanceCounterInstanceLifetime.Global)
{ }
internal unsafe SharedPerformanceCounter(string catName, string counterName, string instanceName, PerformanceCounterInstanceLifetime lifetime)
{
_categoryName = catName;
_categoryNameHashCode = GetWstrHashCode(_categoryName);
_categoryData = GetCategoryData();
// Check that the instance name isn't too long if we're using the new shared memory.
// We allocate InstanceNameSlotSize bytes in the shared memory
if (_categoryData.UseUniqueSharedMemory)
{
if (instanceName != null && instanceName.Length > InstanceNameMaxLength)
throw new InvalidOperationException(SR.InstanceNameTooLong);
}
else
{
if (lifetime != PerformanceCounterInstanceLifetime.Global)
throw new InvalidOperationException(SR.ProcessLifetimeNotValidInGlobal);
}
if (counterName != null && instanceName != null)
{
if (!_categoryData.CounterNames.Contains(counterName))
Debug.Fail("Counter " + counterName + " does not exist in category " + catName);
else
_counterEntryPointer = GetCounter(counterName, instanceName, _categoryData.EnableReuse, lifetime);
}
}
private FileMapping FileView
{
get
{
return _categoryData.FileMapping;
}
}
internal unsafe long Value
{
get
{
if (_counterEntryPointer == null)
return 0;
return GetValue(_counterEntryPointer);
}
set
{
if (_counterEntryPointer == null)
return;
SetValue(_counterEntryPointer, value);
}
}
private unsafe int CalculateAndAllocateMemory(int totalSize, out int alignmentAdjustment)
{
int newOffset;
int oldOffset;
alignmentAdjustment = 0;
Debug.Assert(!_categoryData.UseUniqueSharedMemory, "We should never be calling CalculateAndAllocateMemory in the unique shared memory");
do
{
oldOffset = *((int*)_baseAddress);
// we need to verify the oldOffset before we start using it. Otherwise someone could change
// it to something bogus and we would write outside of the shared memory.
ResolveOffset(oldOffset, 0);
newOffset = CalculateMemory(oldOffset, totalSize, out alignmentAdjustment);
// In the default shared mem we need to make sure that the end address is also aligned. This is because
// in v1.1/v1.0 we just assumed that the next free offset was always properly aligned.
int endAddressMod8 = (int)(_baseAddress + newOffset) & 0x7;
int endAlignmentAdjustment = (8 - endAddressMod8) & 0x7;
newOffset += endAlignmentAdjustment;
} while (Interlocked.CompareExchange(ref *(int*)((IntPtr)_baseAddress).ToPointer(), newOffset, oldOffset) != oldOffset);
return oldOffset;
}
private int CalculateMemory(int oldOffset, int totalSize, out int alignmentAdjustment)
{
int newOffset = CalculateMemoryNoBoundsCheck(oldOffset, totalSize, out alignmentAdjustment);
if (newOffset > FileView._fileMappingSize || newOffset < 0)
{
throw new InvalidOperationException(SR.CountersOOM);
}
return newOffset;
}
private int CalculateMemoryNoBoundsCheck(int oldOffset, int totalSize, out int alignmentAdjustment)
{
int currentTotalSize = totalSize;
Thread.MemoryBarrier();
// make sure the start address is 8 byte aligned
int startAddressMod8 = (int)(_baseAddress + oldOffset) & 0x7;
alignmentAdjustment = (8 - startAddressMod8) & 0x7;
currentTotalSize = currentTotalSize + alignmentAdjustment;
int newOffset = oldOffset + currentTotalSize;
return newOffset;
}
private unsafe int CreateCategory(CategoryEntry* lastCategoryPointer,
int instanceNameHashCode, string instanceName,
PerformanceCounterInstanceLifetime lifetime)
{
int categoryNameLength;
int instanceNameLength;
int alignmentAdjustment;
int freeMemoryOffset;
int newOffset = 0;
int totalSize;
categoryNameLength = (_categoryName.Length + 1) * 2;
totalSize = s_categoryEntrySize + s_instanceEntrySize + (s_counterEntrySize * _categoryData.CounterNames.Count) + categoryNameLength;
for (int i = 0; i < _categoryData.CounterNames.Count; i++)
{
totalSize += (((string)_categoryData.CounterNames[i]).Length + 1) * 2;
}
if (_categoryData.UseUniqueSharedMemory)
{
instanceNameLength = InstanceNameSlotSize;
totalSize += s_processLifetimeEntrySize + instanceNameLength;
// If we're in a separate shared memory, we need to do a two stage update of the free memory pointer.
// First we calculate our alignment adjustment and where the new free offset is. Then we
// write the new structs and data. The last two operations are to link the new structs into the
// existing ones and update the next free offset. Our process could get killed in between those two,
// leaving the memory in an inconsistent state. We use the "IsConsistent" flag to help determine
// when that has happened.
freeMemoryOffset = *((int*)_baseAddress);
newOffset = CalculateMemory(freeMemoryOffset, totalSize, out alignmentAdjustment);
if (freeMemoryOffset == _initialOffset)
lastCategoryPointer->IsConsistent = 0;
}
else
{
instanceNameLength = (instanceName.Length + 1) * 2;
totalSize += instanceNameLength;
freeMemoryOffset = CalculateAndAllocateMemory(totalSize, out alignmentAdjustment);
}
long nextPtr = ResolveOffset(freeMemoryOffset, totalSize + alignmentAdjustment);
CategoryEntry* newCategoryEntryPointer;
InstanceEntry* newInstanceEntryPointer;
// We need to decide where to put the padding returned in alignmentAdjustment. There are several things that
// need to be aligned. First, we need to align each struct on a 4 byte boundary so we can use interlocked
// operations on the int Spinlock field. Second, we need to align the CounterEntry on an 8 byte boundary so that
// on 64 bit platforms we can use interlocked operations on the Value field. alignmentAdjustment guarantees 8 byte
// alignemnt, so we use that for both. If we're creating the very first category, however, we can't move that
// CategoryEntry. In this case we put the alignmentAdjustment before the InstanceEntry.
if (freeMemoryOffset == _initialOffset)
{
newCategoryEntryPointer = (CategoryEntry*)nextPtr;
nextPtr += s_categoryEntrySize + alignmentAdjustment;
newInstanceEntryPointer = (InstanceEntry*)nextPtr;
}
else
{
nextPtr += alignmentAdjustment;
newCategoryEntryPointer = (CategoryEntry*)nextPtr;
nextPtr += s_categoryEntrySize;
newInstanceEntryPointer = (InstanceEntry*)nextPtr;
}
nextPtr += s_instanceEntrySize;
// create the first CounterEntry and reserve space for all of the rest. We won't
// finish creating them until the end
CounterEntry* newCounterEntryPointer = (CounterEntry*)nextPtr;
nextPtr += s_counterEntrySize * _categoryData.CounterNames.Count;
if (_categoryData.UseUniqueSharedMemory)
{
ProcessLifetimeEntry* newLifetimeEntry = (ProcessLifetimeEntry*)nextPtr;
nextPtr += s_processLifetimeEntrySize;
newCounterEntryPointer->LifetimeOffset = (int)((long)newLifetimeEntry - _baseAddress);
PopulateLifetimeEntry(newLifetimeEntry, lifetime);
}
newCategoryEntryPointer->CategoryNameHashCode = _categoryNameHashCode;
newCategoryEntryPointer->NextCategoryOffset = 0;
newCategoryEntryPointer->FirstInstanceOffset = (int)((long)newInstanceEntryPointer - _baseAddress);
newCategoryEntryPointer->CategoryNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(_categoryName, (IntPtr)nextPtr);
nextPtr += categoryNameLength;
newInstanceEntryPointer->InstanceNameHashCode = instanceNameHashCode;
newInstanceEntryPointer->NextInstanceOffset = 0;
newInstanceEntryPointer->FirstCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
newInstanceEntryPointer->RefCount = 1;
newInstanceEntryPointer->InstanceNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(instanceName, (IntPtr)nextPtr);
nextPtr += instanceNameLength;
string counterName = (string)_categoryData.CounterNames[0];
newCounterEntryPointer->CounterNameHashCode = GetWstrHashCode(counterName);
SetValue(newCounterEntryPointer, 0);
newCounterEntryPointer->CounterNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(counterName, (IntPtr)nextPtr);
nextPtr += (counterName.Length + 1) * 2;
CounterEntry* previousCounterEntryPointer;
for (int i = 1; i < _categoryData.CounterNames.Count; i++)
{
previousCounterEntryPointer = newCounterEntryPointer;
counterName = (string)_categoryData.CounterNames[i];
newCounterEntryPointer++;
newCounterEntryPointer->CounterNameHashCode = GetWstrHashCode(counterName);
SetValue(newCounterEntryPointer, 0);
newCounterEntryPointer->CounterNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(counterName, (IntPtr)nextPtr);
nextPtr += (counterName.Length + 1) * 2;
previousCounterEntryPointer->NextCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
}
Debug.Assert(nextPtr - _baseAddress == freeMemoryOffset + totalSize + alignmentAdjustment, "We should have used all of the space we requested at this point");
int offset = (int)((long)newCategoryEntryPointer - _baseAddress);
lastCategoryPointer->IsConsistent = 0;
// If not the first category node, link it.
if (offset != _initialOffset)
lastCategoryPointer->NextCategoryOffset = offset;
if (_categoryData.UseUniqueSharedMemory)
{
*((int*)_baseAddress) = newOffset;
lastCategoryPointer->IsConsistent = 1;
}
return offset;
}
private unsafe int CreateInstance(CategoryEntry* categoryPointer,
int instanceNameHashCode, string instanceName,
PerformanceCounterInstanceLifetime lifetime)
{
int instanceNameLength;
int totalSize = s_instanceEntrySize + (s_counterEntrySize * _categoryData.CounterNames.Count);
int alignmentAdjustment;
int freeMemoryOffset;
int newOffset = 0;
if (_categoryData.UseUniqueSharedMemory)
{
instanceNameLength = InstanceNameSlotSize;
totalSize += s_processLifetimeEntrySize + instanceNameLength;
// If we're in a separate shared memory, we need to do a two stage update of the free memory pointer.
// First we calculate our alignment adjustment and where the new free offset is. Then we
// write the new structs and data. The last two operations are to link the new structs into the
// existing ones and update the next free offset. Our process could get killed in between those two,
// leaving the memory in an inconsistent state. We use the "IsConsistent" flag to help determine
// when that has happened.
freeMemoryOffset = *((int*)_baseAddress);
newOffset = CalculateMemory(freeMemoryOffset, totalSize, out alignmentAdjustment);
}
else
{
instanceNameLength = (instanceName.Length + 1) * 2;
totalSize += instanceNameLength;
// add in the counter names for the global shared mem.
for (int i = 0; i < _categoryData.CounterNames.Count; i++)
{
totalSize += (((string)_categoryData.CounterNames[i]).Length + 1) * 2;
}
freeMemoryOffset = CalculateAndAllocateMemory(totalSize, out alignmentAdjustment);
}
freeMemoryOffset += alignmentAdjustment;
long nextPtr = ResolveOffset(freeMemoryOffset, totalSize); // don't add alignmentAdjustment since it's already
// been added to freeMemoryOffset
InstanceEntry* newInstanceEntryPointer = (InstanceEntry*)nextPtr;
nextPtr += s_instanceEntrySize;
// create the first CounterEntry and reserve space for all of the rest. We won't
// finish creating them until the end
CounterEntry* newCounterEntryPointer = (CounterEntry*)nextPtr;
nextPtr += s_counterEntrySize * _categoryData.CounterNames.Count;
if (_categoryData.UseUniqueSharedMemory)
{
ProcessLifetimeEntry* newLifetimeEntry = (ProcessLifetimeEntry*)nextPtr;
nextPtr += s_processLifetimeEntrySize;
newCounterEntryPointer->LifetimeOffset = (int)((long)newLifetimeEntry - _baseAddress);
PopulateLifetimeEntry(newLifetimeEntry, lifetime);
}
// set up the InstanceEntry
newInstanceEntryPointer->InstanceNameHashCode = instanceNameHashCode;
newInstanceEntryPointer->NextInstanceOffset = 0;
newInstanceEntryPointer->FirstCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
newInstanceEntryPointer->RefCount = 1;
newInstanceEntryPointer->InstanceNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(instanceName, (IntPtr)nextPtr);
nextPtr += instanceNameLength;
if (_categoryData.UseUniqueSharedMemory)
{
// in the unique shared mem we'll assume that the CounterEntries of the first instance
// are all created. Then we can just refer to the old counter name rather than copying in a new one.
InstanceEntry* firstInstanceInCategoryPointer = (InstanceEntry*)ResolveOffset(categoryPointer->FirstInstanceOffset, s_instanceEntrySize);
CounterEntry* firstCounterInCategoryPointer = (CounterEntry*)ResolveOffset(firstInstanceInCategoryPointer->FirstCounterOffset, s_counterEntrySize);
newCounterEntryPointer->CounterNameHashCode = firstCounterInCategoryPointer->CounterNameHashCode;
SetValue(newCounterEntryPointer, 0);
newCounterEntryPointer->CounterNameOffset = firstCounterInCategoryPointer->CounterNameOffset;
// now create the rest of the CounterEntrys
CounterEntry* previousCounterEntryPointer;
for (int i = 1; i < _categoryData.CounterNames.Count; i++)
{
previousCounterEntryPointer = newCounterEntryPointer;
newCounterEntryPointer++;
Debug.Assert(firstCounterInCategoryPointer->NextCounterOffset != 0, "The unique shared memory should have all of its counters created by the time we hit CreateInstance");
firstCounterInCategoryPointer = (CounterEntry*)ResolveOffset(firstCounterInCategoryPointer->NextCounterOffset, s_counterEntrySize);
newCounterEntryPointer->CounterNameHashCode = firstCounterInCategoryPointer->CounterNameHashCode;
SetValue(newCounterEntryPointer, 0);
newCounterEntryPointer->CounterNameOffset = firstCounterInCategoryPointer->CounterNameOffset;
previousCounterEntryPointer->NextCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
}
}
else
{
// now create the rest of the CounterEntrys
CounterEntry* previousCounterEntryPointer = null;
for (int i = 0; i < _categoryData.CounterNames.Count; i++)
{
string counterName = (string)_categoryData.CounterNames[i];
newCounterEntryPointer->CounterNameHashCode = GetWstrHashCode(counterName);
newCounterEntryPointer->CounterNameOffset = (int)(nextPtr - _baseAddress);
SafeMarshalCopy(counterName, (IntPtr)nextPtr);
nextPtr += (counterName.Length + 1) * 2;
SetValue(newCounterEntryPointer, 0);
if (i != 0)
previousCounterEntryPointer->NextCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
previousCounterEntryPointer = newCounterEntryPointer;
newCounterEntryPointer++;
}
}
Debug.Assert(nextPtr - _baseAddress == freeMemoryOffset + totalSize, "We should have used all of the space we requested at this point");
int offset = (int)((long)newInstanceEntryPointer - _baseAddress);
categoryPointer->IsConsistent = 0;
// prepend the new instance rather than append, helps with perf of hooking up subsequent counters
newInstanceEntryPointer->NextInstanceOffset = categoryPointer->FirstInstanceOffset;
categoryPointer->FirstInstanceOffset = offset;
if (_categoryData.UseUniqueSharedMemory)
{
*((int*)_baseAddress) = newOffset;
categoryPointer->IsConsistent = 1;
}
return freeMemoryOffset;
}
private unsafe int CreateCounter(CounterEntry* lastCounterPointer,
int counterNameHashCode, string counterName)
{
int counterNameLength = (counterName.Length + 1) * 2;
int totalSize = sizeof(CounterEntry) + counterNameLength;
int alignmentAdjustment;
int freeMemoryOffset;
Debug.Assert(!_categoryData.UseUniqueSharedMemory, "We should never be calling CreateCounter in the unique shared memory");
freeMemoryOffset = CalculateAndAllocateMemory(totalSize, out alignmentAdjustment);
freeMemoryOffset += alignmentAdjustment;
long nextPtr = ResolveOffset(freeMemoryOffset, totalSize);
CounterEntry* newCounterEntryPointer = (CounterEntry*)nextPtr;
nextPtr += sizeof(CounterEntry);
newCounterEntryPointer->CounterNameOffset = (int)(nextPtr - _baseAddress);
newCounterEntryPointer->CounterNameHashCode = counterNameHashCode;
newCounterEntryPointer->NextCounterOffset = 0;
SetValue(newCounterEntryPointer, 0);
SafeMarshalCopy(counterName, (IntPtr)nextPtr);
Debug.Assert(nextPtr + counterNameLength - _baseAddress == freeMemoryOffset + totalSize, "We should have used all of the space we requested at this point");
lastCounterPointer->NextCounterOffset = (int)((long)newCounterEntryPointer - _baseAddress);
return freeMemoryOffset;
}
private static unsafe void PopulateLifetimeEntry(ProcessLifetimeEntry* lifetimeEntry, PerformanceCounterInstanceLifetime lifetime)
{
if (lifetime == PerformanceCounterInstanceLifetime.Process)
{
lifetimeEntry->LifetimeType = (int)PerformanceCounterInstanceLifetime.Process;
lifetimeEntry->ProcessId = ProcessData.ProcessId;
lifetimeEntry->StartupTime = ProcessData.StartupTime;
}
else
{
lifetimeEntry->ProcessId = 0;
lifetimeEntry->StartupTime = 0;
}
}
private static unsafe void WaitAndEnterCriticalSection(int* spinLockPointer, out bool taken)
{
WaitForCriticalSection(spinLockPointer);
// Note - we are taking a lock here, but it probably isn't
// worthwhile to use Thread.BeginCriticalRegion & EndCriticalRegion.
// These only really help the CLR escalate from a thread abort
// to an appdomain unload, under the assumption that you may be
// editing shared state within the appdomain. Here you are editing
// shared state, but it is shared across processes. Unloading the
// appdomain isn't exactly helping. The only thing that would help
// would be if the CLR tells the host to ensure all allocations
// have a higher chance of succeeding within this critical region,
// but of course that's only a probabilisitic statement.
// Must be able to assign to the out param.
try
{
}
finally
{
int r = Interlocked.CompareExchange(ref *spinLockPointer, 1, 0);
taken = (r == 0);
}
}
private static unsafe void WaitForCriticalSection(int* spinLockPointer)
{
int spinCount = MaxSpinCount;
for (; spinCount > 0 && *spinLockPointer != 0; spinCount--)
{
// We suspect there are scenarios where the finalizer thread
// will call this method. The finalizer thread runs with
// a higher priority than the other code. Using SpinWait
// isn't sufficient, since it only spins, but doesn't yield
// to any lower-priority threads. Call Thread.Sleep(1).
if (*spinLockPointer != 0)
Thread.Sleep(1);
}
// if the lock still isn't free, most likely there's a deadlock caused by a process
// getting killed while it held the lock. We'll just free the lock
if (spinCount == 0 && *spinLockPointer != 0)
*spinLockPointer = 0;
}
private static unsafe void ExitCriticalSection(int* spinLockPointer)
{
*spinLockPointer = 0;
}
// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
// This hashcode function is identical to the one in SharedPerformanceCounter.cpp. If
// you change one without changing the other, perfcounters will break.
internal static int GetWstrHashCode(string wstr)
{
uint hash = 5381;
for (uint i = 0; i < wstr.Length; i++)
hash = ((hash << 5) + hash) ^ wstr[(int)i];
return (int)hash;
}
// Calculate the length of a string in the shared memory. If we reach the end of the shared memory
// before we see a null terminator, we throw.
private unsafe int GetStringLength(char* startChar)
{
char* currentChar = startChar;
ulong endAddress = (ulong)(_baseAddress + FileView._fileMappingSize);
while ((ulong)currentChar < (endAddress - 2))
{
if (*currentChar == 0)
return (int)(currentChar - startChar);
currentChar++;
}
throw new InvalidOperationException(SR.MappingCorrupted);
}
// Compare a managed string to a string located at a given offset. If we walk past the end of the
// shared memory, we throw.
private unsafe bool StringEquals(string stringA, int offset)
{
char* currentChar = (char*)ResolveOffset(offset, 0);
ulong endAddress = (ulong)(_baseAddress + FileView._fileMappingSize);
int i;
for (i = 0; i < stringA.Length; i++)
{
if ((ulong)(currentChar + i) > (endAddress - 2))
throw new InvalidOperationException(SR.MappingCorrupted);
if (stringA[i] != currentChar[i])
return false;
}
// now check for the null termination.
if ((ulong)(currentChar + i) > (endAddress - 2))
throw new InvalidOperationException(SR.MappingCorrupted);
return (currentChar[i] == 0);
}
private unsafe CategoryData GetCategoryData()
{
CategoryData data = (CategoryData)s_categoryDataTable[_categoryName];
if (data == null)
{
lock (s_categoryDataTable)
{
data = (CategoryData)s_categoryDataTable[_categoryName];
if (data == null)
{
data = new CategoryData();
data.FileMappingName = DefaultFileMappingName;
data.MutexName = _categoryName;
RegistryKey categoryKey = null;
try
{
categoryKey = Registry.LocalMachine.OpenSubKey(PerformanceCounterLib.ServicePath + "\\" + _categoryName + "\\Performance");
// first read the options
object optionsObject = categoryKey.GetValue("CategoryOptions");
if (optionsObject != null)
{
int options = (int)optionsObject;
data.EnableReuse = (((PerformanceCounterCategoryOptions)options & PerformanceCounterCategoryOptions.EnableReuse) != 0);
if (((PerformanceCounterCategoryOptions)options & PerformanceCounterCategoryOptions.UseUniqueSharedMemory) != 0)
{
data.UseUniqueSharedMemory = true;
_initialOffset = 8;
data.FileMappingName = DefaultFileMappingName + _categoryName;
}
}
int fileMappingSize;
object fileMappingSizeObject = categoryKey.GetValue("FileMappingSize");
if (fileMappingSizeObject != null && data.UseUniqueSharedMemory)
{
// we only use this reg value in the unique shared memory case.
fileMappingSize = (int)fileMappingSizeObject;
if (fileMappingSize < MinCountersFileMappingSize)
fileMappingSize = MinCountersFileMappingSize;
if (fileMappingSize > MaxCountersFileMappingSize)
fileMappingSize = MaxCountersFileMappingSize;
}
else
{
fileMappingSize = GetFileMappingSizeFromConfig();
if (data.UseUniqueSharedMemory)
fileMappingSize = fileMappingSize >> 2; // if we have a custom filemapping, only make it 25% as large.
}
// now read the counter names
object counterNamesObject = categoryKey.GetValue("Counter Names");
byte[] counterNamesBytes = counterNamesObject as byte[];
if (counterNamesBytes != null)
{
ArrayList names = new ArrayList();
fixed (byte* counterNamesPtr = counterNamesBytes)
{
int start = 0;
for (int i = 0; i < counterNamesBytes.Length - 1; i += 2)
{
if (counterNamesBytes[i] == 0 && counterNamesBytes[i + 1] == 0 && start != i)
{
string counter = new string((sbyte*)counterNamesPtr, start, i - start, Encoding.Unicode);
names.Add(counter.ToLowerInvariant());
start = i + 2;
}
}
}
data.CounterNames = names;
}
else
{
Debug.Assert(counterNamesObject is string[], $"Expected string[], got '{counterNamesObject}' of type '{counterNamesObject?.GetType()}' with kind '{categoryKey.GetValueKind("Counter Names")}' for category '{_categoryName}'");
string[] counterNames = (string[])counterNamesObject;
for (int i = 0; i < counterNames.Length; i++)
counterNames[i] = counterNames[i].ToLowerInvariant();
data.CounterNames = new ArrayList(counterNames);
}
data.FileMappingName = "Global\\" + data.FileMappingName;
data.MutexName = "Global\\" + _categoryName;
data.FileMapping = new FileMapping(data.FileMappingName, fileMappingSize, _initialOffset);
s_categoryDataTable[_categoryName] = data;
}
finally
{
if (categoryKey != null)
categoryKey.Close();
}
}
}
}
_baseAddress = (long)data.FileMapping.FileViewAddress;
if (data.UseUniqueSharedMemory)
_initialOffset = 8;
return data;
}
[MethodImpl(MethodImplOptions.NoInlining)]
private static int GetFileMappingSizeFromConfig()
{
return DiagnosticsConfiguration.PerformanceCountersFileMappingSize;
}
private static void RemoveCategoryData(string categoryName)
{
lock (s_categoryDataTable)
{
s_categoryDataTable.Remove(categoryName);
}
}
private unsafe CounterEntry* GetCounter(string counterName, string instanceName, bool enableReuse, PerformanceCounterInstanceLifetime lifetime)
{
int counterNameHashCode = GetWstrHashCode(counterName);
int instanceNameHashCode;
if (instanceName != null && instanceName.Length != 0)
instanceNameHashCode = GetWstrHashCode(instanceName);
else
{
instanceNameHashCode = s_singleInstanceHashCode;
instanceName = SingleInstanceName;
}
Mutex mutex = null;
CounterEntry* counterPointer = null;
InstanceEntry* instancePointer = null;
try
{
NetFrameworkUtils.EnterMutexWithoutGlobal(_categoryData.MutexName, ref mutex);
CategoryEntry* categoryPointer;
bool counterFound = false;
while (!FindCategory(&categoryPointer))
{
// don't bother locking again if we're using a separate shared memory.
bool sectionEntered;
if (_categoryData.UseUniqueSharedMemory)
sectionEntered = true;
else
WaitAndEnterCriticalSection(&(categoryPointer->SpinLock), out sectionEntered);
int newCategoryOffset;
if (sectionEntered)
{
try
{
newCategoryOffset = CreateCategory(categoryPointer, instanceNameHashCode, instanceName, lifetime);
}
finally
{
if (!_categoryData.UseUniqueSharedMemory)
ExitCriticalSection(&(categoryPointer->SpinLock));
}
categoryPointer = (CategoryEntry*)(ResolveOffset(newCategoryOffset, s_categoryEntrySize));
instancePointer = (InstanceEntry*)(ResolveOffset(categoryPointer->FirstInstanceOffset, s_instanceEntrySize));
counterFound = FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer);
Debug.Assert(counterFound, "All counters should be created, so we should always find the counter");
return counterPointer;
}
}
bool foundFreeInstance;
while (!FindInstance(instanceNameHashCode, instanceName, categoryPointer, &instancePointer, true, lifetime, out foundFreeInstance))
{
InstanceEntry* lockInstancePointer = instancePointer;
// don't bother locking again if we're using a separate shared memory.
bool sectionEntered;
if (_categoryData.UseUniqueSharedMemory)
sectionEntered = true;
else
WaitAndEnterCriticalSection(&(lockInstancePointer->SpinLock), out sectionEntered);
if (sectionEntered)
{
try
{
bool reused = false;
if (enableReuse && foundFreeInstance)
{
reused = TryReuseInstance(instanceNameHashCode, instanceName, categoryPointer, &instancePointer, lifetime, lockInstancePointer);
// at this point we might have reused an instance that came from v1.1/v1.0. We can't assume it will have the counter
// we're looking for.
}
if (!reused)
{
int newInstanceOffset = CreateInstance(categoryPointer, instanceNameHashCode, instanceName, lifetime);
instancePointer = (InstanceEntry*)(ResolveOffset(newInstanceOffset, s_instanceEntrySize));
counterFound = FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer);
Debug.Assert(counterFound, "All counters should be created, so we should always find the counter");
return counterPointer;
}
}
finally
{
if (!_categoryData.UseUniqueSharedMemory)
ExitCriticalSection(&(lockInstancePointer->SpinLock));
}
}
}
if (_categoryData.UseUniqueSharedMemory)
{
counterFound = FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer);
Debug.Assert(counterFound, "All counters should be created, so we should always find the counter");
return counterPointer;
}
else
{
while (!FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer))
{
bool sectionEntered;
WaitAndEnterCriticalSection(&(counterPointer->SpinLock), out sectionEntered);
if (sectionEntered)
{
try
{
int newCounterOffset = CreateCounter(counterPointer, counterNameHashCode, counterName);
return (CounterEntry*)(ResolveOffset(newCounterOffset, s_counterEntrySize));
}
finally
{
ExitCriticalSection(&(counterPointer->SpinLock));
}
}
}
return counterPointer;
}
}
finally
{
// cache this instance for reuse
try
{
if (counterPointer != null && instancePointer != null)
{
_thisInstanceOffset = ResolveAddress((long)instancePointer, s_instanceEntrySize);
}
}
catch (InvalidOperationException)
{
_thisInstanceOffset = -1;
}
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
//
// FindCategory -
//
// * when the function returns true the returnCategoryPointerReference is set to the CategoryEntry
// that matches 'categoryNameHashCode' and 'categoryName'
//
// * when the function returns false the returnCategoryPointerReference is set to the last CategoryEntry
// in the linked list
//
private unsafe bool FindCategory(CategoryEntry** returnCategoryPointerReference)
{
CategoryEntry* firstCategoryPointer = (CategoryEntry*)(ResolveOffset(_initialOffset, s_categoryEntrySize));
CategoryEntry* currentCategoryPointer = firstCategoryPointer;
CategoryEntry* previousCategoryPointer = firstCategoryPointer;
while (true)
{
if (currentCategoryPointer->IsConsistent == 0)
Verify(currentCategoryPointer);
if (currentCategoryPointer->CategoryNameHashCode == _categoryNameHashCode)
{
if (StringEquals(_categoryName, currentCategoryPointer->CategoryNameOffset))
{
*returnCategoryPointerReference = currentCategoryPointer;
return true;
}
}
previousCategoryPointer = currentCategoryPointer;
if (currentCategoryPointer->NextCategoryOffset != 0)
currentCategoryPointer = (CategoryEntry*)(ResolveOffset(currentCategoryPointer->NextCategoryOffset, s_categoryEntrySize));
else
{
*returnCategoryPointerReference = previousCategoryPointer;
return false;
}
}
}
private unsafe bool FindCounter(int counterNameHashCode, string counterName, InstanceEntry* instancePointer, CounterEntry** returnCounterPointerReference)
{
CounterEntry* currentCounterPointer = (CounterEntry*)(ResolveOffset(instancePointer->FirstCounterOffset, s_counterEntrySize));
CounterEntry* previousCounterPointer = currentCounterPointer;
while (true)
{
if (currentCounterPointer->CounterNameHashCode == counterNameHashCode)
{
if (StringEquals(counterName, currentCounterPointer->CounterNameOffset))
{
*returnCounterPointerReference = currentCounterPointer;
return true;
}
}
previousCounterPointer = currentCounterPointer;
if (currentCounterPointer->NextCounterOffset != 0)
currentCounterPointer = (CounterEntry*)(ResolveOffset(currentCounterPointer->NextCounterOffset, s_counterEntrySize));
else
{
*returnCounterPointerReference = previousCounterPointer;
return false;
}
}
}
private unsafe bool FindInstance(int instanceNameHashCode, string instanceName,
CategoryEntry* categoryPointer, InstanceEntry** returnInstancePointerReference,
bool activateUnusedInstances, PerformanceCounterInstanceLifetime lifetime,
out bool foundFreeInstance)
{
InstanceEntry* currentInstancePointer = (InstanceEntry*)(ResolveOffset(categoryPointer->FirstInstanceOffset, s_instanceEntrySize));
InstanceEntry* previousInstancePointer = currentInstancePointer;
foundFreeInstance = false;
// Look at the first instance to determine if this is single or multi instance.
if (currentInstancePointer->InstanceNameHashCode == s_singleInstanceHashCode)
{
if (StringEquals(SingleInstanceName, currentInstancePointer->InstanceNameOffset))
{
if (instanceName != SingleInstanceName)
throw new InvalidOperationException(SR.Format(SR.SingleInstanceOnly, _categoryName));
}
else
{
if (instanceName == SingleInstanceName)
throw new InvalidOperationException(SR.Format(SR.MultiInstanceOnly, _categoryName));
}
}
else
{
if (instanceName == SingleInstanceName)
throw new InvalidOperationException(SR.Format(SR.MultiInstanceOnly, _categoryName));
}
//
// 1st pass find exact matching!
//
// We don't need to aggressively claim unused instances. For performance, we would proactively
// verify lifetime of instances if activateUnusedInstances is specified and certain time
// has elapsed since last sweep or we are running out of shared memory.
bool verifyLifeTime = activateUnusedInstances;
if (activateUnusedInstances)
{
int totalSize = s_instanceEntrySize + s_processLifetimeEntrySize + InstanceNameSlotSize + (s_counterEntrySize * _categoryData.CounterNames.Count);
int freeMemoryOffset = *((int*)_baseAddress);
int alignmentAdjustment;
int newOffset = CalculateMemoryNoBoundsCheck(freeMemoryOffset, totalSize, out alignmentAdjustment);
if (!(newOffset > FileView._fileMappingSize || newOffset < 0))
{
long tickDelta = (DateTime.Now.Ticks - Volatile.Read(ref s_lastInstanceLifetimeSweepTick));
if (tickDelta < InstanceLifetimeSweepWindow)
verifyLifeTime = false;
}
}
try
{
while (true)
{
bool verifiedLifetimeOfThisInstance = false;
if (verifyLifeTime && (currentInstancePointer->RefCount != 0))
{
verifiedLifetimeOfThisInstance = true;
VerifyLifetime(currentInstancePointer);
}
if (currentInstancePointer->InstanceNameHashCode == instanceNameHashCode)
{
if (StringEquals(instanceName, currentInstancePointer->InstanceNameOffset))
{
// we found a matching instance.
*returnInstancePointerReference = currentInstancePointer;
CounterEntry* firstCounter = (CounterEntry*)ResolveOffset(currentInstancePointer->FirstCounterOffset, s_counterEntrySize);
ProcessLifetimeEntry* lifetimeEntry;
if (_categoryData.UseUniqueSharedMemory)
lifetimeEntry = (ProcessLifetimeEntry*)ResolveOffset(firstCounter->LifetimeOffset, s_processLifetimeEntrySize);
else
lifetimeEntry = null;
// ensure that we have verified the lifetime of the matched instance
if (!verifiedLifetimeOfThisInstance && currentInstancePointer->RefCount != 0)
VerifyLifetime(currentInstancePointer);
if (currentInstancePointer->RefCount != 0)
{
if (lifetimeEntry != null && lifetimeEntry->ProcessId != 0)
{
if (lifetime != PerformanceCounterInstanceLifetime.Process)
throw new InvalidOperationException(SR.CantConvertProcessToGlobal);
// make sure only one process is using this instance.
if (ProcessData.ProcessId != lifetimeEntry->ProcessId)
throw new InvalidOperationException(SR.Format(SR.InstanceAlreadyExists, instanceName));
// compare start time of the process, account for ACL issues in querying process information
if ((lifetimeEntry->StartupTime != -1) && (ProcessData.StartupTime != -1))
{
if (ProcessData.StartupTime != lifetimeEntry->StartupTime)
throw new InvalidOperationException(SR.Format(SR.InstanceAlreadyExists, instanceName));
}
}
else
{
if (lifetime == PerformanceCounterInstanceLifetime.Process)
throw new InvalidOperationException(SR.CantConvertGlobalToProcess);
}
return true;
}
if (activateUnusedInstances)
{
Mutex mutex = null;
try
{
NetFrameworkUtils.EnterMutexWithoutGlobal(_categoryData.MutexName, ref mutex);
ClearCounterValues(currentInstancePointer);
if (lifetimeEntry != null)
PopulateLifetimeEntry(lifetimeEntry, lifetime);
currentInstancePointer->RefCount = 1;
return true;
}
finally
{
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
else
return false;
}
}
if (currentInstancePointer->RefCount == 0)
{
foundFreeInstance = true;
}
previousInstancePointer = currentInstancePointer;
if (currentInstancePointer->NextInstanceOffset != 0)
currentInstancePointer = (InstanceEntry*)(ResolveOffset(currentInstancePointer->NextInstanceOffset, s_instanceEntrySize));
else
{
*returnInstancePointerReference = previousInstancePointer;
return false;
}
}
}
finally
{
if (verifyLifeTime)
Volatile.Write(ref s_lastInstanceLifetimeSweepTick, DateTime.Now.Ticks);
}
}
private unsafe bool TryReuseInstance(int instanceNameHashCode, string instanceName,
CategoryEntry* categoryPointer, InstanceEntry** returnInstancePointerReference,
PerformanceCounterInstanceLifetime lifetime,
InstanceEntry* lockInstancePointer)
{
// 2nd pass find a free instance slot
InstanceEntry* currentInstancePointer = (InstanceEntry*)(ResolveOffset(categoryPointer->FirstInstanceOffset, s_instanceEntrySize));
InstanceEntry* previousInstancePointer = currentInstancePointer;
while (true)
{
if (currentInstancePointer->RefCount == 0)
{
bool hasFit;
long instanceNamePtr; // we need cache this to avoid race conditions.
if (_categoryData.UseUniqueSharedMemory)
{
instanceNamePtr = ResolveOffset(currentInstancePointer->InstanceNameOffset, InstanceNameSlotSize);
// In the separate shared memory case we should always have enough space for instances. The
// name slot size is fixed.
Debug.Assert(((instanceName.Length + 1) * 2) <= InstanceNameSlotSize, "The instance name length should always fit in our slot size");
hasFit = true;
}
else
{
// we don't know the string length yet.
instanceNamePtr = ResolveOffset(currentInstancePointer->InstanceNameOffset, 0);
// In the global shared memory, we require names to be exactly the same length in order
// to reuse them. This way we don't end up leaking any space and we don't need to
// depend on the layout of the memory to calculate the space we have.
int length = GetStringLength((char*)instanceNamePtr);
hasFit = (length == instanceName.Length);
}
bool noSpinLock = (lockInstancePointer == currentInstancePointer) || _categoryData.UseUniqueSharedMemory;
// Instance name fit
if (hasFit)
{
// don't bother locking again if we're using a separate shared memory.
bool sectionEntered;
if (noSpinLock)
sectionEntered = true;
else
WaitAndEnterCriticalSection(&(currentInstancePointer->SpinLock), out sectionEntered);
if (sectionEntered)
{
try
{
// Make copy with zero-term
SafeMarshalCopy(instanceName, (IntPtr)instanceNamePtr);
currentInstancePointer->InstanceNameHashCode = instanceNameHashCode;
// return
*returnInstancePointerReference = currentInstancePointer;
// clear the counter values.
ClearCounterValues(*returnInstancePointerReference);
if (_categoryData.UseUniqueSharedMemory)
{
CounterEntry* counterPointer = (CounterEntry*)ResolveOffset(currentInstancePointer->FirstCounterOffset, s_counterEntrySize);
ProcessLifetimeEntry* lifetimeEntry = (ProcessLifetimeEntry*)ResolveOffset(counterPointer->LifetimeOffset, s_processLifetimeEntrySize);
PopulateLifetimeEntry(lifetimeEntry, lifetime);
}
(*returnInstancePointerReference)->RefCount = 1;
return true;
}
finally
{
if (!noSpinLock)
ExitCriticalSection(&(currentInstancePointer->SpinLock));
}
}
}
}
previousInstancePointer = currentInstancePointer;
if (currentInstancePointer->NextInstanceOffset != 0)
currentInstancePointer = (InstanceEntry*)(ResolveOffset(currentInstancePointer->NextInstanceOffset, s_instanceEntrySize));
else
{
*returnInstancePointerReference = previousInstancePointer;
return false;
}
}
}
private unsafe void Verify(CategoryEntry* currentCategoryPointer)
{
if (!_categoryData.UseUniqueSharedMemory)
return;
Mutex mutex = null;
try
{
NetFrameworkUtils.EnterMutexWithoutGlobal(_categoryData.MutexName, ref mutex);
VerifyCategory(currentCategoryPointer);
}
finally
{
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
private unsafe void VerifyCategory(CategoryEntry* currentCategoryPointer)
{
int freeOffset = *((int*)_baseAddress);
ResolveOffset(freeOffset, 0); // verify next free offset
// begin by verifying the head node's offset
int currentOffset = ResolveAddress((long)currentCategoryPointer, s_categoryEntrySize);
if (currentOffset >= freeOffset)
{
// zero out the bad head node entry
currentCategoryPointer->SpinLock = 0;
currentCategoryPointer->CategoryNameHashCode = 0;
currentCategoryPointer->CategoryNameOffset = 0;
currentCategoryPointer->FirstInstanceOffset = 0;
currentCategoryPointer->NextCategoryOffset = 0;
currentCategoryPointer->IsConsistent = 0;
return;
}
if (currentCategoryPointer->NextCategoryOffset > freeOffset)
currentCategoryPointer->NextCategoryOffset = 0;
else if (currentCategoryPointer->NextCategoryOffset != 0)
VerifyCategory((CategoryEntry*)ResolveOffset(currentCategoryPointer->NextCategoryOffset, s_categoryEntrySize));
if (currentCategoryPointer->FirstInstanceOffset != 0)
{
// Check whether the recently added instance at the head of the list is committed. If not, rewire
// the head of the list to point to the next instance
if (currentCategoryPointer->FirstInstanceOffset > freeOffset)
{
InstanceEntry* currentInstancePointer = (InstanceEntry*)ResolveOffset(currentCategoryPointer->FirstInstanceOffset, s_instanceEntrySize);
currentCategoryPointer->FirstInstanceOffset = currentInstancePointer->NextInstanceOffset;
if (currentCategoryPointer->FirstInstanceOffset > freeOffset)
currentCategoryPointer->FirstInstanceOffset = 0;
}
if (currentCategoryPointer->FirstInstanceOffset != 0)
{
Debug.Assert(currentCategoryPointer->FirstInstanceOffset <= freeOffset, "The head of the list is inconsistent - possible mismatch of V2 & V3 instances?");
VerifyInstance((InstanceEntry*)ResolveOffset(currentCategoryPointer->FirstInstanceOffset, s_instanceEntrySize));
}
}
currentCategoryPointer->IsConsistent = 1;
}
private unsafe void VerifyInstance(InstanceEntry* currentInstancePointer)
{
int freeOffset = *((int*)_baseAddress);
ResolveOffset(freeOffset, 0); // verify next free offset
if (currentInstancePointer->NextInstanceOffset > freeOffset)
currentInstancePointer->NextInstanceOffset = 0;
else if (currentInstancePointer->NextInstanceOffset != 0)
VerifyInstance((InstanceEntry*)ResolveOffset(currentInstancePointer->NextInstanceOffset, s_instanceEntrySize));
}
private unsafe void VerifyLifetime(InstanceEntry* currentInstancePointer)
{
Debug.Assert(currentInstancePointer->RefCount != 0, "RefCount must be 1 for instances passed to VerifyLifetime");
CounterEntry* counter = (CounterEntry*)ResolveOffset(currentInstancePointer->FirstCounterOffset, s_counterEntrySize);
if (counter->LifetimeOffset != 0)
{
ProcessLifetimeEntry* lifetime = (ProcessLifetimeEntry*)ResolveOffset(counter->LifetimeOffset, s_processLifetimeEntrySize);
if (lifetime->LifetimeType == (int)PerformanceCounterInstanceLifetime.Process)
{
int pid = lifetime->ProcessId;
long startTime = lifetime->StartupTime;
if (pid != 0)
{
// Optimize for this process
if (pid == ProcessData.ProcessId)
{
if ((ProcessData.StartupTime != -1) && (startTime != -1) && (ProcessData.StartupTime != startTime))
{
// Process id got recycled. Reclaim this instance.
currentInstancePointer->RefCount = 0;
return;
}
}
else
{
long processStartTime;
using (SafeProcessHandle procHandle = Interop.Kernel32.OpenProcess(Interop.Advapi32.ProcessOptions.PROCESS_QUERY_INFORMATION, false, pid))
{
int error = Marshal.GetLastWin32Error();
if ((error == Interop.Errors.ERROR_INVALID_PARAMETER) && procHandle.IsInvalid)
{
// The process is dead. Reclaim this instance. Note that we only clear the refcount here.
// If we tried to clear the pid and startup time as well, we would have a race where
// we could clear the pid/startup time but not the refcount.
currentInstancePointer->RefCount = 0;
return;
}
// Defer cleaning the instance when we had previously encountered errors in
// recording process start time (i.e, when startTime == -1) until after the
// process id is not valid (which will be caught in the if check above)
if (!procHandle.IsInvalid && startTime != -1)
{
long temp;
if (Interop.Kernel32.GetProcessTimes(procHandle, out processStartTime, out temp, out temp, out temp))
{
if (processStartTime != startTime)
{
// The process is dead but a new one is using the same pid. Reclaim this instance.
currentInstancePointer->RefCount = 0;
return;
}
}
}
}
// Check to see if the process handle has been signaled by the kernel. If this is the case then it's safe
// to reclaim the instance as the process is in the process of exiting.
using (SafeProcessHandle procHandle = Interop.Kernel32.OpenProcess(Interop.Advapi32.ProcessOptions.SYNCHRONIZE, false, pid))
{
if (!procHandle.IsInvalid)
{
using (Interop.Kernel32.ProcessWaitHandle wh = new Interop.Kernel32.ProcessWaitHandle(procHandle))
{
if (wh.WaitOne(0, false))
{
// Process has exited
currentInstancePointer->RefCount = 0;
return;
}
}
}
}
}
}
}
}
}
internal unsafe long IncrementBy(long value)
{
if (_counterEntryPointer == null)
return 0;
CounterEntry* counterEntry = _counterEntryPointer;
return AddToValue(counterEntry, value);
}
internal unsafe long Increment()
{
if (_counterEntryPointer == null)
return 0;
return IncrementUnaligned(_counterEntryPointer);
}
internal unsafe long Decrement()
{
if (_counterEntryPointer == null)
return 0;
return DecrementUnaligned(_counterEntryPointer);
}
internal static unsafe void RemoveAllInstances(string categoryName)
{
SharedPerformanceCounter spc = new SharedPerformanceCounter(categoryName, null, null);
spc.RemoveAllInstances();
RemoveCategoryData(categoryName);
}
private unsafe void RemoveAllInstances()
{
CategoryEntry* categoryPointer;
if (!FindCategory(&categoryPointer))
return;
InstanceEntry* instancePointer = (InstanceEntry*)(ResolveOffset(categoryPointer->FirstInstanceOffset, s_instanceEntrySize));
Mutex mutex = null;
try
{
NetFrameworkUtils.EnterMutexWithoutGlobal(_categoryData.MutexName, ref mutex);
while (true)
{
RemoveOneInstance(instancePointer, true);
if (instancePointer->NextInstanceOffset != 0)
instancePointer = (InstanceEntry*)(ResolveOffset(instancePointer->NextInstanceOffset, s_instanceEntrySize));
else
{
break;
}
}
}
finally
{
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
internal unsafe void RemoveInstance(string instanceName, PerformanceCounterInstanceLifetime instanceLifetime)
{
if (instanceName == null || instanceName.Length == 0)
return;
int instanceNameHashCode = GetWstrHashCode(instanceName);
CategoryEntry* categoryPointer;
if (!FindCategory(&categoryPointer))
return;
InstanceEntry* instancePointer = null;
bool validatedCachedInstancePointer = false;
bool temp;
Mutex mutex = null;
try
{
NetFrameworkUtils.EnterMutexWithoutGlobal(_categoryData.MutexName, ref mutex);
if (_thisInstanceOffset != -1)
{
try
{
// validate whether the cached instance pointer is pointing at the right instance
instancePointer = (InstanceEntry*)(ResolveOffset(_thisInstanceOffset, s_instanceEntrySize));
if (instancePointer->InstanceNameHashCode == instanceNameHashCode)
{
if (StringEquals(instanceName, instancePointer->InstanceNameOffset))
{
validatedCachedInstancePointer = true;
CounterEntry* firstCounter = (CounterEntry*)ResolveOffset(instancePointer->FirstCounterOffset, s_counterEntrySize);
ProcessLifetimeEntry* lifetimeEntry;
if (_categoryData.UseUniqueSharedMemory)
{
lifetimeEntry = (ProcessLifetimeEntry*)ResolveOffset(firstCounter->LifetimeOffset, s_processLifetimeEntrySize);
if (lifetimeEntry != null
&& lifetimeEntry->LifetimeType == (int)PerformanceCounterInstanceLifetime.Process
&& lifetimeEntry->ProcessId != 0)
{
validatedCachedInstancePointer &= (instanceLifetime == PerformanceCounterInstanceLifetime.Process);
validatedCachedInstancePointer &= (ProcessData.ProcessId == lifetimeEntry->ProcessId);
if ((lifetimeEntry->StartupTime != -1) && (ProcessData.StartupTime != -1))
validatedCachedInstancePointer &= (ProcessData.StartupTime == lifetimeEntry->StartupTime);
}
else
validatedCachedInstancePointer &= (instanceLifetime != PerformanceCounterInstanceLifetime.Process);
}
}
}
}
catch (InvalidOperationException)
{
validatedCachedInstancePointer = false;
}
if (!validatedCachedInstancePointer)
_thisInstanceOffset = -1;
}
if (!validatedCachedInstancePointer && !FindInstance(instanceNameHashCode, instanceName, categoryPointer, &instancePointer, false, instanceLifetime, out temp))
return;
if (instancePointer != null)
RemoveOneInstance(instancePointer, false);
}
finally
{
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
private unsafe void RemoveOneInstance(InstanceEntry* instancePointer, bool clearValue)
{
bool sectionEntered = false;
try
{
if (!_categoryData.UseUniqueSharedMemory)
{
while (!sectionEntered)
{
WaitAndEnterCriticalSection(&(instancePointer->SpinLock), out sectionEntered);
}
}
instancePointer->RefCount = 0;
if (clearValue)
ClearCounterValues(instancePointer);
}
finally
{
if (sectionEntered)
ExitCriticalSection(&(instancePointer->SpinLock));
}
}
private unsafe void ClearCounterValues(InstanceEntry* instancePointer)
{
//Clear counter instance values
CounterEntry* currentCounterPointer = null;
if (instancePointer->FirstCounterOffset != 0)
currentCounterPointer = (CounterEntry*)(ResolveOffset(instancePointer->FirstCounterOffset, s_counterEntrySize));
while (currentCounterPointer != null)
{
SetValue(currentCounterPointer, 0);
if (currentCounterPointer->NextCounterOffset != 0)
currentCounterPointer = (CounterEntry*)(ResolveOffset(currentCounterPointer->NextCounterOffset, s_counterEntrySize));
else
currentCounterPointer = null;
}
}
private static unsafe long AddToValue(CounterEntry* counterEntry, long addend)
{
// Called while holding a lock - shouldn't have to worry about
// reading misaligned data & getting old vs. new parts of an Int64.
if (IsMisaligned(counterEntry))
{
ulong newvalue;
CounterEntryMisaligned* entry = (CounterEntryMisaligned*)counterEntry;
newvalue = (uint)entry->Value_hi;
newvalue <<= 32;
newvalue |= (uint)entry->Value_lo;
newvalue = (ulong)((long)newvalue + addend);
entry->Value_hi = (int)(newvalue >> 32);
entry->Value_lo = (int)(newvalue & 0xffffffff);
return (long)newvalue;
}
else
return Interlocked.Add(ref counterEntry->Value, addend);
}
private static unsafe long DecrementUnaligned(CounterEntry* counterEntry)
{
if (IsMisaligned(counterEntry))
return AddToValue(counterEntry, -1);
else
return Interlocked.Decrement(ref counterEntry->Value);
}
private static unsafe long GetValue(CounterEntry* counterEntry)
{
if (IsMisaligned(counterEntry))
{
ulong value;
CounterEntryMisaligned* entry = (CounterEntryMisaligned*)counterEntry;
value = (uint)entry->Value_hi;
value <<= 32;
value |= (uint)entry->Value_lo;
return (long)value;
}
else
return counterEntry->Value;
}
private static unsafe long IncrementUnaligned(CounterEntry* counterEntry)
{
if (IsMisaligned(counterEntry))
return AddToValue(counterEntry, 1);
else
return Interlocked.Increment(ref counterEntry->Value);
}
private static unsafe void SetValue(CounterEntry* counterEntry, long value)
{
if (IsMisaligned(counterEntry))
{
CounterEntryMisaligned* entry = (CounterEntryMisaligned*)counterEntry;
entry->Value_lo = (int)(value & 0xffffffff);
entry->Value_hi = (int)(value >> 32);
}
else
counterEntry->Value = value;
}
private static unsafe bool IsMisaligned(CounterEntry* counterEntry)
{
return (((long)counterEntry & 0x7) != 0);
}
private long ResolveOffset(int offset, int sizeToRead)
{
//It is very important to check the integrity of the shared memory
//everytime a new address is resolved.
if (offset > (FileView._fileMappingSize - sizeToRead) || offset < 0)
throw new InvalidOperationException(SR.MappingCorrupted);
long address = _baseAddress + offset;
return address;
}
private int ResolveAddress(long address, int sizeToRead)
{
int offset = (int)(address - _baseAddress);
//It is very important to check the integrity of the shared memory
//everytime a new address is resolved.
if (offset > (FileView._fileMappingSize - sizeToRead) || offset < 0)
throw new InvalidOperationException(SR.MappingCorrupted);
return offset;
}
private sealed class FileMapping
{
internal int _fileMappingSize;
private SafeMemoryMappedViewHandle _fileViewAddress;
private SafeMemoryMappedFileHandle _fileMappingHandle;
//The version of the file mapping name is independent from the
//assembly version.
public FileMapping(string fileMappingName, int fileMappingSize, int initialOffset)
{
Initialize(fileMappingName, fileMappingSize, initialOffset);
}
internal IntPtr FileViewAddress
{
get
{
if (_fileViewAddress.IsInvalid)
throw new InvalidOperationException(SR.SharedMemoryGhosted);
return _fileViewAddress.DangerousGetHandle();
}
}
private unsafe void Initialize(string fileMappingName, int fileMappingSize, int initialOffset)
{
string mappingName = fileMappingName;
SafeLocalAllocHandle securityDescriptorPointer = null;
try
{
// The sddl string consists of these parts:
// D: it's a DACL
// (A; this is an allow ACE
// OICI; object inherit and container inherit
// FRFWGRGW;;; allow file read, file write, generic read and generic write
// AU) granted to Authenticated Users
// ;S-1-5-33) the same permission granted to AU is also granted to restricted services
string sddlString = "D:(A;OICI;FRFWGRGW;;;AU)(A;OICI;FRFWGRGW;;;S-1-5-33)";
if (!Interop.Advapi32.ConvertStringSecurityDescriptorToSecurityDescriptor(sddlString, Interop.Kernel32.PerformanceCounterOptions.SDDL_REVISION_1,
out securityDescriptorPointer, IntPtr.Zero))
throw new InvalidOperationException(SR.SetSecurityDescriptorFailed);
Interop.Kernel32.SECURITY_ATTRIBUTES securityAttributes = default;
securityAttributes.lpSecurityDescriptor = securityDescriptorPointer.DangerousGetHandle();
securityAttributes.bInheritHandle = Interop.BOOL.FALSE;
//
//
// Here we call CreateFileMapping to create the memory mapped file. When CreateFileMapping fails
// with ERROR_ACCESS_DENIED, we know the file mapping has been created and we then open it with OpenFileMapping.
//
// There is chance of a race condition between CreateFileMapping and OpenFileMapping; The memory mapped file
// may actually be closed in between these two calls. When this happens, OpenFileMapping returns ERROR_FILE_NOT_FOUND.
// In this case, we need to loop back and retry creating the memory mapped file.
//
// This loop will timeout in approximately 1.4 minutes. An InvalidOperationException is thrown in the timeout case.
//
//
int waitRetries = 14; //((2^13)-1)*10ms == approximately 1.4mins
int waitSleep = 0;
bool created = false;
while (!created && waitRetries > 0)
{
_fileMappingHandle = Interop.Kernel32.CreateFileMapping((IntPtr)(-1), ref securityAttributes,
Interop.Kernel32.PageOptions.PAGE_READWRITE, 0, fileMappingSize, mappingName);
if ((Marshal.GetLastWin32Error() != Interop.Errors.ERROR_ACCESS_DENIED) || !_fileMappingHandle.IsInvalid)
{
created = true;
}
else
{
// Invalidate the old safehandle before we get rid of it. This prevents it from trying to finalize
_fileMappingHandle.SetHandleAsInvalid();
_fileMappingHandle = Interop.Kernel32.OpenFileMapping(Interop.Kernel32.FileMapOptions.FILE_MAP_WRITE, false, mappingName);
if ((Marshal.GetLastWin32Error() != Interop.Errors.ERROR_FILE_NOT_FOUND) || !_fileMappingHandle.IsInvalid)
{
created = true;
}
else
{
--waitRetries;
if (waitSleep == 0)
{
waitSleep = 10;
}
else
{
System.Threading.Thread.Sleep(waitSleep);
waitSleep *= 2;
}
}
}
}
if (_fileMappingHandle.IsInvalid)
{
throw new InvalidOperationException(SR.CantCreateFileMapping);
}
_fileViewAddress = Interop.Kernel32.MapViewOfFile(_fileMappingHandle, Interop.Kernel32.FileMapOptions.FILE_MAP_WRITE, 0, 0, UIntPtr.Zero);
if (_fileViewAddress.IsInvalid)
throw new InvalidOperationException(SR.CantMapFileView);
// figure out what size the share memory really is.
Interop.Kernel32.MEMORY_BASIC_INFORMATION meminfo = default;
if (Interop.Kernel32.VirtualQuery(_fileViewAddress, ref meminfo, (UIntPtr)sizeof(Interop.Kernel32.MEMORY_BASIC_INFORMATION)) == UIntPtr.Zero)
throw new InvalidOperationException(SR.CantGetMappingSize);
_fileMappingSize = (int)meminfo.RegionSize;
}
finally
{
if (securityDescriptorPointer != null)
securityDescriptorPointer.Close();
}
Interlocked.CompareExchange(ref *(int*)_fileViewAddress.DangerousGetHandle().ToPointer(), initialOffset, 0);
}
}
// SafeMarshalCopy always null terminates the char array
// before copying it to native memory
//
private static void SafeMarshalCopy(string str, IntPtr nativePointer)
{
// convert str to a char array and copy it to the unmanaged memory pointer
char[] tmp = new char[str.Length + 1];
str.CopyTo(0, tmp, 0, str.Length);
tmp[str.Length] = '\0'; // make sure the char[] is null terminated
Marshal.Copy(tmp, 0, nativePointer, tmp.Length);
}
// <WARNING>
// The final tmpPadding field is needed to make the size of this structure 8-byte aligned. This is
// necessary on IA64.
// </WARNING>
// Note that in V1.0 and v1.1 there was no explicit padding defined on any of these structs. That means that
// sizeof(CategoryEntry) or Marshal.SizeOf(typeof(CategoryEntry)) returned 4 bytes less before Whidbey,
// and the int we use as IsConsistent could actually overlap the InstanceEntry SpinLock.
[StructLayout(LayoutKind.Sequential)]
private struct CategoryEntry
{
public int SpinLock;
public int CategoryNameHashCode;
public int CategoryNameOffset;
public int FirstInstanceOffset;
public int NextCategoryOffset;
public int IsConsistent; // this was 4 bytes of padding in v1.0/v1.1
}
[StructLayout(LayoutKind.Sequential)]
private struct InstanceEntry
{
public int SpinLock;
public int InstanceNameHashCode;
public int InstanceNameOffset;
public int RefCount;
public int FirstCounterOffset;
public int NextInstanceOffset;
}
[StructLayout(LayoutKind.Sequential)]
private struct CounterEntry
{
public int SpinLock;
public int CounterNameHashCode;
public int CounterNameOffset;
public int LifetimeOffset; // this was 4 bytes of padding in v1.0/v1.1
public long Value;
public int NextCounterOffset;
public int padding2;
}
[StructLayout(LayoutKind.Sequential)]
private struct CounterEntryMisaligned
{
public int SpinLock;
public int CounterNameHashCode;
public int CounterNameOffset;
public int LifetimeOffset; // this was 4 bytes of padding in v1.0/v1.1
public int Value_lo;
public int Value_hi;
public int NextCounterOffset;
public int padding2; // The compiler adds this only if there is an int64 in the struct -
// ie only for CounterEntry. It really needs to be here.
}
[StructLayout(LayoutKind.Sequential)]
private struct ProcessLifetimeEntry
{
public int LifetimeType;
public int ProcessId;
public long StartupTime;
}
private sealed class CategoryData
{
public FileMapping FileMapping;
public bool EnableReuse;
public bool UseUniqueSharedMemory;
public string FileMappingName;
public string MutexName;
public ArrayList CounterNames;
}
}
internal sealed class ProcessData
{
public ProcessData(int pid, long startTime)
{
ProcessId = pid;
StartupTime = startTime;
}
public int ProcessId;
public long StartupTime;
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Speech/src/Internal/AlphabetConverter.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Text;
using Microsoft.Win32;
namespace System.Speech.Internal
{
internal enum AlphabetType
{
Sapi, Ipa, Ups
}
/// <summary>
/// This class allows conversion between SAPI and IPA phonemes.
/// Objects of this class are not thread safe for modifying state.
/// </summary>
internal class AlphabetConverter
{
#region Constructors
internal AlphabetConverter(int langId)
{
_currentLangId = -1;
SetLanguageId(langId);
}
#endregion
#region internal Methods
/// <summary>
/// Convert from SAPI phonemes to IPA phonemes.
/// </summary>
/// <returns>
/// Return an array of unicode characters each of which represents an IPA phoneme if the SAPI phonemes are valid.
/// Otherwise, return null.
/// </returns>
internal char[] SapiToIpa(char[] phonemes)
{
return Convert(phonemes, true);
}
/// <summary>
/// Convert from IPA phonemes to SAPI phonemes.
/// </summary>
/// Return an array of unicode characters each of which represents a SAPI phoneme if the IPA phonemes are valid.
/// Otherwise, return null.
internal char[] IpaToSapi(char[] phonemes)
{
return Convert(phonemes, false);
}
/// <summary>
/// Determines whether a given string of SAPI ids can be potentially converted using a single
/// conversion unit, that is, a prefix of some convertible string.
/// </summary>
/// <param name="phonemes">The string of SAPI or UPS phoneme ids</param>
/// <param name="isSapi">To indicate whether parameter phonemes is in SAPI or UPS phonemes</param>
internal bool IsPrefix(string phonemes, bool isSapi)
{
if (_phoneMap == null)
return false;
return _phoneMap.IsPrefix(phonemes, isSapi);
}
internal bool IsConvertibleUnit(string phonemes, bool isSapi)
{
if (_phoneMap == null)
return false;
return _phoneMap.ConvertPhoneme(phonemes, isSapi) != null;
}
internal int SetLanguageId(int langId)
{
if (langId < 0)
{
throw new ArgumentException(SR.Get(SRID.MustBeGreaterThanZero), nameof(langId));
}
if (langId == _currentLangId)
{
return _currentLangId;
}
int i;
int oldLangId = _currentLangId;
for (i = 0; i < s_langIds.Length; i++)
{
if (s_langIds[i] == langId)
{
break;
}
}
if (i == s_langIds.Length)
{
//Debug.Fail($"No phoneme map for LCID {langId}, maps exist for {string.Join(',', s_langIds)}\n");
_currentLangId = langId;
_phoneMap = null;
}
else
{
lock (s_staticLock)
{
if (s_phoneMaps[i] == null)
{
s_phoneMaps[i] = CreateMap(s_resourceNames[i]);
}
_phoneMap = s_phoneMaps[i];
_currentLangId = langId;
}
}
return oldLangId;
}
#endregion
#region Private Methods
private char[] Convert(char[] phonemes, bool isSapi)
{
// If the phoneset of the selected language is UPS anyway, that is phone mapping is unnecessary,
// we return the same phoneme string. But we still need to make a copy.
if (_phoneMap == null || phonemes.Length == 0)
{
return (char[])phonemes.Clone();
}
//
// We break the phoneme string into substrings of phonemes, each of which is directly convertible from
// the mapping table. If there is ambiguity, we always choose the largest substring as we go from left
// to right.
//
// In order to do this, we check whether a given substring is a potential prefix of a convertible substring.
//
StringBuilder result = new();
int startIndex; // Starting index of a substring being considered
int endIndex; // The ending index of the last convertible substring
string token; // Holds a substring of phonemes that are directly convertible from the mapping table.
string lastConvert; // Holds last convertible substring, starting from startIndex.
string tempConvert;
string source = new(phonemes);
int i;
lastConvert = null;
startIndex = i = 0;
endIndex = -1;
while (i < source.Length)
{
token = source.Substring(startIndex, i - startIndex + 1);
if (_phoneMap.IsPrefix(token, isSapi))
{
tempConvert = _phoneMap.ConvertPhoneme(token, isSapi);
// Note we may have an empty string for conversion result here
if (tempConvert != null)
{
lastConvert = tempConvert;
endIndex = i;
}
}
else
{
// If we have not had a convertible substring, the input is not convertible.
if (lastConvert == null)
{
break;
}
else
{
// Use the converted substring, and start over from the last convertible position.
result.Append(lastConvert);
i = endIndex;
startIndex = endIndex + 1;
lastConvert = null;
}
}
i++;
}
if (lastConvert != null && endIndex == phonemes.Length - 1)
{
result.Append(lastConvert);
}
else
{
return null;
}
return result.ToString().ToCharArray();
}
private PhoneMapData CreateMap(string resourceName)
{
Assembly assembly = Assembly.GetAssembly(GetType());
Stream stream = assembly.GetManifestResourceStream(resourceName);
if (stream == null)
{
throw new FileLoadException(SR.Get(SRID.CannotLoadResourceFromManifest, resourceName, assembly.FullName));
}
return new PhoneMapData(new BufferedStream(stream));
}
#endregion
#region Private Fields
private int _currentLangId;
private PhoneMapData _phoneMap;
private static int[] s_langIds = new int[] { 0x804, 0x404, 0x407, 0x409, 0x40A, 0x40C, 0x411 };
private static string[] s_resourceNames =
new string[] { "upstable_chs.upsmap", "upstable_cht.upsmap", "upstable_deu.upsmap", "upstable_enu.upsmap",
"upstable_esp.upsmap", "upstable_fra.upsmap", "upstable_jpn.upsmap",
};
private static PhoneMapData[] s_phoneMaps = new PhoneMapData[7];
private static object s_staticLock = new();
#endregion
#region Private Type
internal class PhoneMapData
{
private sealed class ConversionUnit
{
public string sapi;
public string ups;
public bool isDefault;
}
internal PhoneMapData(Stream input)
{
using (BinaryReader reader = new(input, System.Text.Encoding.Unicode))
{
int size = reader.ReadInt32();
_convertTable = new ConversionUnit[size];
int i;
for (i = 0; i < size; i++)
{
_convertTable[i] = new ConversionUnit
{
sapi = ReadPhoneString(reader),
ups = ReadPhoneString(reader),
isDefault = reader.ReadInt32() != 0 ? true : false
};
}
_prefixSapiTable = InitializePrefix(true);
_prefixUpsTable = InitializePrefix(false);
}
}
internal bool IsPrefix(string prefix, bool isSapi)
{
if (isSapi)
{
return _prefixSapiTable.ContainsKey(prefix);
}
else
{
return _prefixUpsTable.ContainsKey(prefix);
}
}
internal string ConvertPhoneme(string phoneme, bool isSapi)
{
ConversionUnit unit;
if (isSapi)
{
unit = (ConversionUnit)_prefixSapiTable[phoneme];
}
else
{
unit = (ConversionUnit)_prefixUpsTable[phoneme];
}
if (unit == null)
{
return null;
}
return isSapi ? unit.ups : unit.sapi;
}
/// <summary>
/// Create a hash table of all possible prefix substrings for each ConversionUnit
/// </summary>
/// <param name="isSapi">Creating a SAPI or UPS prefix table</param>
private Hashtable InitializePrefix(bool isSapi)
{
int i, j;
Hashtable prefixTable = Hashtable.Synchronized(new Hashtable());
string from, key;
for (i = 0; i < _convertTable.Length; i++)
{
if (isSapi)
{
from = _convertTable[i].sapi;
}
else
{
from = _convertTable[i].ups;
}
for (j = 0; j + 1 < from.Length; j++)
{
key = from.Substring(0, j + 1);
if (!prefixTable.ContainsKey(key))
{
prefixTable[key] = null;
}
}
if (_convertTable[i].isDefault || prefixTable[from] == null)
{
prefixTable[from] = _convertTable[i];
}
}
return prefixTable;
}
private static string ReadPhoneString(BinaryReader reader)
{
int phoneLength;
char[] phoneString;
phoneLength = reader.ReadInt16() / 2;
phoneString = reader.ReadChars(phoneLength);
return new string(phoneString, 0, phoneLength - 1);
}
private Hashtable _prefixSapiTable, _prefixUpsTable;
private ConversionUnit[] _convertTable;
}
#endregion
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Text;
using Microsoft.Win32;
namespace System.Speech.Internal
{
internal enum AlphabetType
{
Sapi, Ipa, Ups
}
/// <summary>
/// This class allows conversion between SAPI and IPA phonemes.
/// Objects of this class are not thread safe for modifying state.
/// </summary>
internal class AlphabetConverter
{
#region Constructors
internal AlphabetConverter(int langId)
{
_currentLangId = -1;
SetLanguageId(langId);
}
#endregion
#region internal Methods
/// <summary>
/// Convert from SAPI phonemes to IPA phonemes.
/// </summary>
/// <returns>
/// Return an array of unicode characters each of which represents an IPA phoneme if the SAPI phonemes are valid.
/// Otherwise, return null.
/// </returns>
internal char[] SapiToIpa(char[] phonemes)
{
return Convert(phonemes, true);
}
/// <summary>
/// Convert from IPA phonemes to SAPI phonemes.
/// </summary>
/// Return an array of unicode characters each of which represents a SAPI phoneme if the IPA phonemes are valid.
/// Otherwise, return null.
internal char[] IpaToSapi(char[] phonemes)
{
return Convert(phonemes, false);
}
/// <summary>
/// Determines whether a given string of SAPI ids can be potentially converted using a single
/// conversion unit, that is, a prefix of some convertible string.
/// </summary>
/// <param name="phonemes">The string of SAPI or UPS phoneme ids</param>
/// <param name="isSapi">To indicate whether parameter phonemes is in SAPI or UPS phonemes</param>
internal bool IsPrefix(string phonemes, bool isSapi)
{
if (_phoneMap == null)
return false;
return _phoneMap.IsPrefix(phonemes, isSapi);
}
internal bool IsConvertibleUnit(string phonemes, bool isSapi)
{
if (_phoneMap == null)
return false;
return _phoneMap.ConvertPhoneme(phonemes, isSapi) != null;
}
internal int SetLanguageId(int langId)
{
if (langId < 0)
{
throw new ArgumentException(SR.Get(SRID.MustBeGreaterThanZero), nameof(langId));
}
if (langId == _currentLangId)
{
return _currentLangId;
}
int i;
int oldLangId = _currentLangId;
for (i = 0; i < s_langIds.Length; i++)
{
if (s_langIds[i] == langId)
{
break;
}
}
if (i == s_langIds.Length)
{
//Debug.Fail($"No phoneme map for LCID {langId}, maps exist for {string.Join(',', s_langIds)}\n");
_currentLangId = langId;
_phoneMap = null;
}
else
{
lock (s_staticLock)
{
if (s_phoneMaps[i] == null)
{
s_phoneMaps[i] = CreateMap(s_resourceNames[i]);
}
_phoneMap = s_phoneMaps[i];
_currentLangId = langId;
}
}
return oldLangId;
}
#endregion
#region Private Methods
private char[] Convert(char[] phonemes, bool isSapi)
{
// If the phoneset of the selected language is UPS anyway, that is phone mapping is unnecessary,
// we return the same phoneme string. But we still need to make a copy.
if (_phoneMap == null || phonemes.Length == 0)
{
return (char[])phonemes.Clone();
}
//
// We break the phoneme string into substrings of phonemes, each of which is directly convertible from
// the mapping table. If there is ambiguity, we always choose the largest substring as we go from left
// to right.
//
// In order to do this, we check whether a given substring is a potential prefix of a convertible substring.
//
StringBuilder result = new();
int startIndex; // Starting index of a substring being considered
int endIndex; // The ending index of the last convertible substring
string token; // Holds a substring of phonemes that are directly convertible from the mapping table.
string lastConvert; // Holds last convertible substring, starting from startIndex.
string tempConvert;
string source = new(phonemes);
int i;
lastConvert = null;
startIndex = i = 0;
endIndex = -1;
while (i < source.Length)
{
token = source.Substring(startIndex, i - startIndex + 1);
if (_phoneMap.IsPrefix(token, isSapi))
{
tempConvert = _phoneMap.ConvertPhoneme(token, isSapi);
// Note we may have an empty string for conversion result here
if (tempConvert != null)
{
lastConvert = tempConvert;
endIndex = i;
}
}
else
{
// If we have not had a convertible substring, the input is not convertible.
if (lastConvert == null)
{
break;
}
else
{
// Use the converted substring, and start over from the last convertible position.
result.Append(lastConvert);
i = endIndex;
startIndex = endIndex + 1;
lastConvert = null;
}
}
i++;
}
if (lastConvert != null && endIndex == phonemes.Length - 1)
{
result.Append(lastConvert);
}
else
{
return null;
}
return result.ToString().ToCharArray();
}
private PhoneMapData CreateMap(string resourceName)
{
Assembly assembly = Assembly.GetAssembly(GetType());
Stream stream = assembly.GetManifestResourceStream(resourceName);
if (stream == null)
{
throw new FileLoadException(SR.Get(SRID.CannotLoadResourceFromManifest, resourceName, assembly.FullName));
}
return new PhoneMapData(new BufferedStream(stream));
}
#endregion
#region Private Fields
private int _currentLangId;
private PhoneMapData _phoneMap;
private static int[] s_langIds = new int[] { 0x804, 0x404, 0x407, 0x409, 0x40A, 0x40C, 0x411 };
private static string[] s_resourceNames =
new string[] { "upstable_chs.upsmap", "upstable_cht.upsmap", "upstable_deu.upsmap", "upstable_enu.upsmap",
"upstable_esp.upsmap", "upstable_fra.upsmap", "upstable_jpn.upsmap",
};
private static PhoneMapData[] s_phoneMaps = new PhoneMapData[7];
private static object s_staticLock = new();
#endregion
#region Private Type
internal class PhoneMapData
{
private sealed class ConversionUnit
{
public string sapi;
public string ups;
public bool isDefault;
}
internal PhoneMapData(Stream input)
{
using (BinaryReader reader = new(input, System.Text.Encoding.Unicode))
{
int size = reader.ReadInt32();
_convertTable = new ConversionUnit[size];
int i;
for (i = 0; i < size; i++)
{
_convertTable[i] = new ConversionUnit
{
sapi = ReadPhoneString(reader),
ups = ReadPhoneString(reader),
isDefault = reader.ReadInt32() != 0 ? true : false
};
}
_prefixSapiTable = InitializePrefix(true);
_prefixUpsTable = InitializePrefix(false);
}
}
internal bool IsPrefix(string prefix, bool isSapi)
{
if (isSapi)
{
return _prefixSapiTable.ContainsKey(prefix);
}
else
{
return _prefixUpsTable.ContainsKey(prefix);
}
}
internal string ConvertPhoneme(string phoneme, bool isSapi)
{
ConversionUnit unit;
if (isSapi)
{
unit = (ConversionUnit)_prefixSapiTable[phoneme];
}
else
{
unit = (ConversionUnit)_prefixUpsTable[phoneme];
}
if (unit == null)
{
return null;
}
return isSapi ? unit.ups : unit.sapi;
}
/// <summary>
/// Create a hash table of all possible prefix substrings for each ConversionUnit
/// </summary>
/// <param name="isSapi">Creating a SAPI or UPS prefix table</param>
private Hashtable InitializePrefix(bool isSapi)
{
int i, j;
Hashtable prefixTable = Hashtable.Synchronized(new Hashtable());
string from, key;
for (i = 0; i < _convertTable.Length; i++)
{
if (isSapi)
{
from = _convertTable[i].sapi;
}
else
{
from = _convertTable[i].ups;
}
for (j = 0; j + 1 < from.Length; j++)
{
key = from.Substring(0, j + 1);
if (!prefixTable.ContainsKey(key))
{
prefixTable[key] = null;
}
}
if (_convertTable[i].isDefault || prefixTable[from] == null)
{
prefixTable[from] = _convertTable[i];
}
}
return prefixTable;
}
private static string ReadPhoneString(BinaryReader reader)
{
int phoneLength;
char[] phoneString;
phoneLength = reader.ReadInt16() / 2;
phoneString = reader.ReadChars(phoneLength);
return new string(phoneString, 0, phoneLength - 1);
}
private Hashtable _prefixSapiTable, _prefixUpsTable;
private ConversionUnit[] _convertTable;
}
#endregion
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/LeadingZeroCount.Vector128.UInt16.cs
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void LeadingZeroCount_Vector128_UInt16()
{
var test = new SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16
{
private struct DataTable
{
private byte[] inArray1;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle outHandle;
private ulong alignment;
public DataTable(UInt16[] inArray1, UInt16[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<UInt16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<UInt16>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<UInt16, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<UInt16> _fld1;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref testStruct._fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
return testStruct;
}
public void RunStructFldScenario(SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16 testClass)
{
var result = AdvSimd.LeadingZeroCount(_fld1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16 testClass)
{
fixed (Vector128<UInt16>* pFld1 = &_fld1)
{
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<UInt16>>() / sizeof(UInt16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector128<UInt16>>() / sizeof(UInt16);
private static UInt16[] _data1 = new UInt16[Op1ElementCount];
private static Vector128<UInt16> _clsVar1;
private Vector128<UInt16> _fld1;
private DataTable _dataTable;
static SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
public SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
_dataTable = new DataTable(_data1, new UInt16[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.LeadingZeroCount(
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.LeadingZeroCount), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr)
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.LeadingZeroCount), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.LeadingZeroCount(
_clsVar1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<UInt16>* pClsVar1 = &_clsVar1)
{
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(pClsVar1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr);
var result = AdvSimd.LeadingZeroCount(op1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr));
var result = AdvSimd.LeadingZeroCount(op1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16();
var result = AdvSimd.LeadingZeroCount(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16();
fixed (Vector128<UInt16>* pFld1 = &test._fld1)
{
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.LeadingZeroCount(_fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<UInt16>* pFld1 = &_fld1)
{
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.LeadingZeroCount(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(&test._fld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<UInt16> op1, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), op1);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.CountLeadingZeroBits(firstOp[i]) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.LeadingZeroCount)}<UInt16>(Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace JIT.HardwareIntrinsics.Arm
{
public static partial class Program
{
private static void LeadingZeroCount_Vector128_UInt16()
{
var test = new SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16();
if (test.IsSupported)
{
// Validates basic functionality works, using Unsafe.Read
test.RunBasicScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates basic functionality works, using Load
test.RunBasicScenario_Load();
}
// Validates calling via reflection works, using Unsafe.Read
test.RunReflectionScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates calling via reflection works, using Load
test.RunReflectionScenario_Load();
}
// Validates passing a static member works
test.RunClsVarScenario();
if (AdvSimd.IsSupported)
{
// Validates passing a static member works, using pinning and Load
test.RunClsVarScenario_Load();
}
// Validates passing a local works, using Unsafe.Read
test.RunLclVarScenario_UnsafeRead();
if (AdvSimd.IsSupported)
{
// Validates passing a local works, using Load
test.RunLclVarScenario_Load();
}
// Validates passing the field of a local class works
test.RunClassLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local class works, using pinning and Load
test.RunClassLclFldScenario_Load();
}
// Validates passing an instance member of a class works
test.RunClassFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a class works, using pinning and Load
test.RunClassFldScenario_Load();
}
// Validates passing the field of a local struct works
test.RunStructLclFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing the field of a local struct works, using pinning and Load
test.RunStructLclFldScenario_Load();
}
// Validates passing an instance member of a struct works
test.RunStructFldScenario();
if (AdvSimd.IsSupported)
{
// Validates passing an instance member of a struct works, using pinning and Load
test.RunStructFldScenario_Load();
}
}
else
{
// Validates we throw on unsupported hardware
test.RunUnsupportedScenario();
}
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16
{
private struct DataTable
{
private byte[] inArray1;
private byte[] outArray;
private GCHandle inHandle1;
private GCHandle outHandle;
private ulong alignment;
public DataTable(UInt16[] inArray1, UInt16[] outArray, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<UInt16>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<UInt16>();
if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
this.inArray1 = new byte[alignment * 2];
this.outArray = new byte[alignment * 2];
this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
this.alignment = (ulong)alignment;
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<UInt16, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
}
public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
public void Dispose()
{
inHandle1.Free();
outHandle.Free();
}
private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
{
return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
}
}
private struct TestStruct
{
public Vector128<UInt16> _fld1;
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref testStruct._fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
return testStruct;
}
public void RunStructFldScenario(SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16 testClass)
{
var result = AdvSimd.LeadingZeroCount(_fld1);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16 testClass)
{
fixed (Vector128<UInt16>* pFld1 = &_fld1)
{
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr);
}
}
}
private static readonly int LargestVectorSize = 16;
private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector128<UInt16>>() / sizeof(UInt16);
private static readonly int RetElementCount = Unsafe.SizeOf<Vector128<UInt16>>() / sizeof(UInt16);
private static UInt16[] _data1 = new UInt16[Op1ElementCount];
private static Vector128<UInt16> _clsVar1;
private Vector128<UInt16> _fld1;
private DataTable _dataTable;
static SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
public SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16()
{
Succeeded = true;
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _fld1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
_dataTable = new DataTable(_data1, new UInt16[RetElementCount], LargestVectorSize);
}
public bool IsSupported => AdvSimd.IsSupported;
public bool Succeeded { get; set; }
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = AdvSimd.LeadingZeroCount(
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.LeadingZeroCount), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr)
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.LeadingZeroCount), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128<UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = AdvSimd.LeadingZeroCount(
_clsVar1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _dataTable.outArrayPtr);
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector128<UInt16>* pClsVar1 = &_clsVar1)
{
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(pClsVar1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _dataTable.outArrayPtr);
}
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr);
var result = AdvSimd.LeadingZeroCount(op1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var op1 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr));
var result = AdvSimd.LeadingZeroCount(op1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16();
var result = AdvSimd.LeadingZeroCount(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleUnaryOpTest__LeadingZeroCount_Vector128_UInt16();
fixed (Vector128<UInt16>* pFld1 = &test._fld1)
{
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = AdvSimd.LeadingZeroCount(_fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector128<UInt16>* pFld1 = &_fld1)
{
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(pFld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = AdvSimd.LeadingZeroCount(test._fld1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = AdvSimd.LeadingZeroCount(
AdvSimd.LoadVector128((UInt16*)(&test._fld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
public void RunStructFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
var test = TestStruct.Create();
test.RunStructFldScenario_Load(this);
}
public void RunUnsupportedScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
bool succeeded = false;
try
{
RunBasicScenario_UnsafeRead();
}
catch (PlatformNotSupportedException)
{
succeeded = true;
}
if (!succeeded)
{
Succeeded = false;
}
}
private void ValidateResult(Vector128<UInt16> op1, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), op1);
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "")
{
UInt16[] inArray1 = new UInt16[Op1ElementCount];
UInt16[] outArray = new UInt16[RetElementCount];
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
ValidateResult(inArray1, outArray, method);
}
private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
{
bool succeeded = true;
for (var i = 0; i < RetElementCount; i++)
{
if (Helpers.CountLeadingZeroBits(firstOp[i]) != result[i])
{
succeeded = false;
break;
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.LeadingZeroCount)}<UInt16>(Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime
| 66,363 |
Clean up NonBacktracking DgmlWriter
|
I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
stephentoub
| 2022-03-08T22:25:09Z | 2022-03-10T18:33:14Z |
f63e4d93fb4d1158e8f099cbbdd24b3555d2c583
|
406d8541926a608ec636b8e4865b4d168273aba3
|
Clean up NonBacktracking DgmlWriter. I was experimenting with the DGML produced for NonBacktracking and did some cleanup in the writer code along the way.
|
./src/libraries/System.Reflection.Metadata/tests/Resources/NetModule/ModuleVB01.mod
|
MZ @ !L!This program cannot be run in DOS mode.
$ PE L [KL
) @ @ ` @ \) O @ H .text
`.reloc @ @ B ) H 8! $ (
*0
r p
+ * * 0
+ * 0 jo
*0
+ * >
s
*b{ (
t } * b{ (
t } * * 0 # q %
s (
+ * BSJB v4.0.30319 l #~ #Strings #US #GUID $ #Blob W
%3 y y ' Wy y y y y )y y ) 4 @ %
O ` ) j S h~ V V V V P X K p P t V [ /h az s ! ! F7 Fg F 8 C T q ! y c c C <p Mu
<Module> mscorlib Microsoft.VisualBasic ModVBClass ModVBStruct ModVBInnerEnum ModVBInnerStruct ModVBDele ModVBInnerIFoo System Object .ctor ConstString get_ModVBDefaultProp index set_ModVBDefaultProp value ModuleCS00.mod NS.Module ModStruct get_ModVBProp ModEnum ModClass BCSub01 em cls Action ModDele BCFunc02 del ModVBDefaultProp ModVBProp ValueType .cctor ArrayField add_AnEvent obj AnEventEvent remove_AnEvent EventArgs EventHandler1 o e BSFunc01 p AnEvent Enum value__ None Red Yellow Blue MulticastDelegate TargetObject TargetMethod IAsyncResult AsyncCallback BeginInvoke DelegateCallback DelegateAsyncState EndInvoke DelegateAsyncResult Invoke ModIBase ModIDerive CM System.Reflection DefaultMemberAttribute Delegate Combine Remove ModuleVB01.mod A A A ħxPGx z\V4?_
: 0V B C o n s t a n t S t r i n g F i e l d
(( !
- !1 - 9
5 ModVBDefaultProp AAA ) ) ) _CorExeMain mscoree.dll % @ 9
|
MZ @ !L!This program cannot be run in DOS mode.
$ PE L [KL
) @ @ ` @ \) O @ H .text
`.reloc @ @ B ) H 8! $ (
*0
r p
+ * * 0
+ * 0 jo
*0
+ * >
s
*b{ (
t } * b{ (
t } * * 0 # q %
s (
+ * BSJB v4.0.30319 l #~ #Strings #US #GUID $ #Blob W
%3 y y ' Wy y y y y )y y ) 4 @ %
O ` ) j S h~ V V V V P X K p P t V [ /h az s ! ! F7 Fg F 8 C T q ! y c c C <p Mu
<Module> mscorlib Microsoft.VisualBasic ModVBClass ModVBStruct ModVBInnerEnum ModVBInnerStruct ModVBDele ModVBInnerIFoo System Object .ctor ConstString get_ModVBDefaultProp index set_ModVBDefaultProp value ModuleCS00.mod NS.Module ModStruct get_ModVBProp ModEnum ModClass BCSub01 em cls Action ModDele BCFunc02 del ModVBDefaultProp ModVBProp ValueType .cctor ArrayField add_AnEvent obj AnEventEvent remove_AnEvent EventArgs EventHandler1 o e BSFunc01 p AnEvent Enum value__ None Red Yellow Blue MulticastDelegate TargetObject TargetMethod IAsyncResult AsyncCallback BeginInvoke DelegateCallback DelegateAsyncState EndInvoke DelegateAsyncResult Invoke ModIBase ModIDerive CM System.Reflection DefaultMemberAttribute Delegate Combine Remove ModuleVB01.mod A A A ħxPGx z\V4?_
: 0V B C o n s t a n t S t r i n g F i e l d
(( !
- !1 - 9
5 ModVBDefaultProp AAA ) ) ) _CorExeMain mscoree.dll % @ 9
| -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.