public final class ComplexPerformance_absMathHypot_jmhTest {

    byte p000, p001, p002, p003, p004, p005, p006, p007, p008, p009, p010, p011, p012, p013, p014, p015;
    byte p016, p017, p018, p019, p020, p021, p022, p023, p024, p025, p026, p027, p028, p029, p030, p031;
    byte p032, p033, p034, p035, p036, p037, p038, p039, p040, p041, p042, p043, p044, p045, p046, p047;
    byte p048, p049, p050, p051, p052, p053, p054, p055, p056, p057, p058, p059, p060, p061, p062, p063;
    byte p064, p065, p066, p067, p068, p069, p070, p071, p072, p073, p074, p075, p076, p077, p078, p079;
    byte p080, p081, p082, p083, p084, p085, p086, p087, p088, p089, p090, p091, p092, p093, p094, p095;
    byte p096, p097, p098, p099, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111;
    byte p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127;
    byte p128, p129, p130, p131, p132, p133, p134, p135, p136, p137, p138, p139, p140, p141, p142, p143;
    byte p144, p145, p146, p147, p148, p149, p150, p151, p152, p153, p154, p155, p156, p157, p158, p159;
    byte p160, p161, p162, p163, p164, p165, p166, p167, p168, p169, p170, p171, p172, p173, p174, p175;
    byte p176, p177, p178, p179, p180, p181, p182, p183, p184, p185, p186, p187, p188, p189, p190, p191;
    byte p192, p193, p194, p195, p196, p197, p198, p199, p200, p201, p202, p203, p204, p205, p206, p207;
    byte p208, p209, p210, p211, p212, p213, p214, p215, p216, p217, p218, p219, p220, p221, p222, p223;
    byte p224, p225, p226, p227, p228, p229, p230, p231, p232, p233, p234, p235, p236, p237, p238, p239;
    byte p240, p241, p242, p243, p244, p245, p246, p247, p248, p249, p250, p251, p252, p253, p254, p255;
    int startRndMask;
    BenchmarkParams benchmarkParams;
    IterationParams iterationParams;
    ThreadParams threadParams;
    Blackhole blackhole;
    Control notifyControl;

    public BenchmarkTaskResult absMathHypot_Throughput(InfraControl control, ThreadParams threadParams) throws Throwable {

public class SinCosPerformance_Numbers_jmhType_B1 extends org.apache.commons.numbers.examples.jmh.complex.SinCosPerformance.Numbers {
    byte p000, p001, p002, p003, p004, p005, p006, p007, p008, p009, p010, p011, p012, p013, p014, p015;
    byte p016, p017, p018, p019, p020, p021, p022, p023, p024, p025, p026, p027, p028, p029, p030, p031;
    byte p032, p033, p034, p035, p036, p037, p038, p039, p040, p041, p042, p043, p044, p045, p046, p047;
    byte p048, p049, p050, p051, p052, p053, p054, p055, p056, p057, p058, p059, p060, p061, p062, p063;
    byte p064, p065, p066, p067, p068, p069, p070, p071, p072, p073, p074, p075, p076, p077, p078, p079;
    byte p080, p081, p082, p083, p084, p085, p086, p087, p088, p089, p090, p091, p092, p093, p094, p095;
    byte p096, p097, p098, p099, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111;
    byte p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127;
    byte p128, p129, p130, p131, p132, p133, p134, p135, p136, p137, p138, p139, p140, p141, p142, p143;
    byte p144, p145, p146, p147, p148, p149, p150, p151, p152, p153, p154, p155, p156, p157, p158, p159;
    byte p160, p161, p162, p163, p164, p165, p166, p167, p168, p169, p170, p171, p172, p173, p174, p175;
    byte p176, p177, p178, p179, p180, p181, p182, p183, p184, p185, p186, p187, p188, p189, p190, p191;
    byte p192, p193, p194, p195, p196, p197, p198, p199, p200, p201, p202, p203, p204, p205, p206, p207;
    byte p208, p209, p210, p211, p212, p213, p214, p215, p216, p217, p218, p219, p220, p221, p222, p223;
    byte p224, p225, p226, p227, p228, p229, p230, p231, p232, p233, p234, p235, p236, p237, p238, p239;
    byte p240, p241, p242, p243, p244, p245, p246, p247, p248, p249, p250, p251, p252, p253, p254, p255;
}

public class DoubleSplitPerformance_BiFactors_jmhType_B1 extends org.apache.commons.numbers.examples.jmh.core.DoubleSplitPerformance.BiFactors {
    byte p000, p001, p002, p003, p004, p005, p006, p007, p008, p009, p010, p011, p012, p013, p014, p015;
    byte p016, p017, p018, p019, p020, p021, p022, p023, p024, p025, p026, p027, p028, p029, p030, p031;
    byte p032, p033, p034, p035, p036, p037, p038, p039, p040, p041, p042, p043, p044, p045, p046, p047;
    byte p048, p049, p050, p051, p052, p053, p054, p055, p056, p057, p058, p059, p060, p061, p062, p063;
    byte p064, p065, p066, p067, p068, p069, p070, p071, p072, p073, p074, p075, p076, p077, p078, p079;
    byte p080, p081, p082, p083, p084, p085, p086, p087, p088, p089, p090, p091, p092, p093, p094, p095;
    byte p096, p097, p098, p099, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111;
    byte p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127;
    byte p128, p129, p130, p131, p132, p133, p134, p135, p136, p137, p138, p139, p140, p141, p142, p143;
    byte p144, p145, p146, p147, p148, p149, p150, p151, p152, p153, p154, p155, p156, p157, p158, p159;
    byte p160, p161, p162, p163, p164, p165, p166, p167, p168, p169, p170, p171, p172, p173, p174, p175;
    byte p176, p177, p178, p179, p180, p181, p182, p183, p184, p185, p186, p187, p188, p189, p190, p191;
    byte p192, p193, p194, p195, p196, p197, p198, p199, p200, p201, p202, p203, p204, p205, p206, p207;
    byte p208, p209, p210, p211, p212, p213, p214, p215, p216, p217, p218, p219, p220, p221, p222, p223;
    byte p224, p225, p226, p227, p228, p229, p230, p231, p232, p233, p234, p235, p236, p237, p238, p239;
    byte p240, p241, p242, p243, p244, p245, p246, p247, p248, p249, p250, p251, p252, p253, p254, p255;
}

public class EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType_B1 extends org.apache.commons.numbers.examples.jmh.core.EuclideanNormAlgorithmPerformance.VectorArrayInput {
    byte p000, p001, p002, p003, p004, p005, p006, p007, p008, p009, p010, p011, p012, p013, p014, p015;
    byte p016, p017, p018, p019, p020, p021, p022, p023, p024, p025, p026, p027, p028, p029, p030, p031;
    byte p032, p033, p034, p035, p036, p037, p038, p039, p040, p041, p042, p043, p044, p045, p046, p047;
    byte p048, p049, p050, p051, p052, p053, p054, p055, p056, p057, p058, p059, p060, p061, p062, p063;
    byte p064, p065, p066, p067, p068, p069, p070, p071, p072, p073, p074, p075, p076, p077, p078, p079;
    byte p080, p081, p082, p083, p084, p085, p086, p087, p088, p089, p090, p091, p092, p093, p094, p095;
    byte p096, p097, p098, p099, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111;
    byte p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127;
    byte p128, p129, p130, p131, p132, p133, p134, p135, p136, p137, p138, p139, p140, p141, p142, p143;
    byte p144, p145, p146, p147, p148, p149, p150, p151, p152, p153, p154, p155, p156, p157, p158, p159;
    byte p160, p161, p162, p163, p164, p165, p166, p167, p168, p169, p170, p171, p172, p173, p174, p175;
    byte p176, p177, p178, p179, p180, p181, p182, p183, p184, p185, p186, p187, p188, p189, p190, p191;
    byte p192, p193, p194, p195, p196, p197, p198, p199, p200, p201, p202, p203, p204, p205, p206, p207;
    byte p208, p209, p210, p211, p212, p213, p214, p215, p216, p217, p218, p219, p220, p221, p222, p223;
    byte p224, p225, p226, p227, p228, p229, p230, p231, p232, p233, p234, p235, p236, p237, p238, p239;
    byte p240, p241, p242, p243, p244, p245, p246, p247, p248, p249, p250, p251, p252, p253, p254, p255;
}

public class ErfPerformance_BaseData_jmhType_B1 extends org.apache.commons.numbers.examples.jmh.gamma.ErfPerformance.BaseData {
    byte p000, p001, p002, p003, p004, p005, p006, p007, p008, p009, p010, p011, p012, p013, p014, p015;
    byte p016, p017, p018, p019, p020, p021, p022, p023, p024, p025, p026, p027, p028, p029, p030, p031;
    byte p032, p033, p034, p035, p036, p037, p038, p039, p040, p041, p042, p043, p044, p045, p046, p047;
    byte p048, p049, p050, p051, p052, p053, p054, p055, p056, p057, p058, p059, p060, p061, p062, p063;
    byte p064, p065, p066, p067, p068, p069, p070, p071, p072, p073, p074, p075, p076, p077, p078, p079;
    byte p080, p081, p082, p083, p084, p085, p086, p087, p088, p089, p090, p091, p092, p093, p094, p095;
    byte p096, p097, p098, p099, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111;
    byte p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127;
    byte p128, p129, p130, p131, p132, p133, p134, p135, p136, p137, p138, p139, p140, p141, p142, p143;
    byte p144, p145, p146, p147, p148, p149, p150, p151, p152, p153, p154, p155, p156, p157, p158, p159;
    byte p160, p161, p162, p163, p164, p165, p166, p167, p168, p169, p170, p171, p172, p173, p174, p175;
    byte p176, p177, p178, p179, p180, p181, p182, p183, p184, p185, p186, p187, p188, p189, p190, p191;
    byte p192, p193, p194, p195, p196, p197, p198, p199, p200, p201, p202, p203, p204, p205, p206, p207;
    byte p208, p209, p210, p211, p212, p213, p214, p215, p216, p217, p218, p219, p220, p221, p222, p223;
    byte p224, p225, p226, p227, p228, p229, p230, p231, p232, p233, p234, p235, p236, p237, p238, p239;
    byte p240, p241, p242, p243, p244, p245, p246, p247, p248, p249, p250, p251, p252, p253, p254, p255;
}

public class ComplexPerformance_ComplexAndRealNumbers_jmhType_B1 extends org.apache.commons.numbers.examples.jmh.complex.ComplexPerformance.ComplexAndRealNumbers {
    byte p000, p001, p002, p003, p004, p005, p006, p007, p008, p009, p010, p011, p012, p013, p014, p015;
    byte p016, p017, p018, p019, p020, p021, p022, p023, p024, p025, p026, p027, p028, p029, p030, p031;
    byte p032, p033, p034, p035, p036, p037, p038, p039, p040, p041, p042, p043, p044, p045, p046, p047;
    byte p048, p049, p050, p051, p052, p053, p054, p055, p056, p057, p058, p059, p060, p061, p062, p063;
    byte p064, p065, p066, p067, p068, p069, p070, p071, p072, p073, p074, p075, p076, p077, p078, p079;
    byte p080, p081, p082, p083, p084, p085, p086, p087, p088, p089, p090, p091, p092, p093, p094, p095;
    byte p096, p097, p098, p099, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111;
    byte p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127;
    byte p128, p129, p130, p131, p132, p133, p134, p135, p136, p137, p138, p139, p140, p141, p142, p143;
    byte p144, p145, p146, p147, p148, p149, p150, p151, p152, p153, p154, p155, p156, p157, p158, p159;
    byte p160, p161, p162, p163, p164, p165, p166, p167, p168, p169, p170, p171, p172, p173, p174, p175;
    byte p176, p177, p178, p179, p180, p181, p182, p183, p184, p185, p186, p187, p188, p189, p190, p191;
    byte p192, p193, p194, p195, p196, p197, p198, p199, p200, p201, p202, p203, p204, p205, p206, p207;
    byte p208, p209, p210, p211, p212, p213, p214, p215, p216, p217, p218, p219, p220, p221, p222, p223;
    byte p224, p225, p226, p227, p228, p229, p230, p231, p232, p233, p234, p235, p236, p237, p238, p239;
    byte p240, p241, p242, p243, p244, p245, p246, p247, p248, p249, p250, p251, p252, p253, p254, p255;
}

l_linearcombinationperformance0_G.fourD(l_factors1_G, blackhole, l_calculator2_G);
        }
        result.stopTime = System.nanoTime();
        result.realTime = realTime;
    }

    
    static volatile LinearCombinationPerformance_Calculator_jmhType f_calculator2_G;
    
    LinearCombinationPerformance_Calculator_jmhType _jmh_tryInit_f_calculator2_G(InfraControl control) throws Throwable {
        LinearCombinationPerformance_Calculator_jmhType val = f_calculator2_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_calculator2_G;
            if (val != null) {
                return val;
            }
            val = new LinearCombinationPerformance_Calculator_jmhType();
            Field f;
            f = org.apache.commons.numbers.examples.jmh.core.LinearCombinationPerformance.Calculator.class.getDeclaredField("name");
            f.setAccessible(true);
            f.set(val, control.getParam("name"));
            val.setup();
            val.readyTrial = true;
            f_calculator2_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }
    
    static volatile LinearCombinationPerformance_Factors_jmhType f_factors1_G;
    
    LinearCombinationPerformance_Factors_jmhType _jmh_tryInit_f_factors1_G(InfraControl control) throws Throwable {
        LinearCombinationPerformance_Factors_jmhType val = f_factors1_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_factors1_G;
            if (val != null) {
                return val;
            }
            val = new LinearCombinationPerformance_Factors_jmhType();
            Field f;
            f = org.apache.commons.numbers.examples.jmh.core.LinearCombinationPerformance.Factors.class.getDeclaredField("c");
            f.setAccessible(true);
            f.set(val, Double.valueOf(control.getParam("c")));
            f = org.apache.commons.numbers.examples.jmh.core.LinearCombinationPerformance.Factors.class.getDeclaredField("size");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("size")));
            val.setup();
            val.readyTrial = true;
            f_factors1_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }
    
    static volatile LinearCombinationPerformance_jmhType f_linearcombinationperformance0_G;
    
    LinearCombinationPerformance_jmhType _jmh_tryInit_f_linearcombinationperformance0_G(InfraControl control) throws Throwable {
        LinearCombinationPerformance_jmhType val = f_linearcombinationperformance0_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_linearcombinationperformance0_G;
            if (val != null) {
                return val;
            }
            val = new LinearCombinationPerformance_jmhType();
            val.readyTrial = true;
            f_linearcombinationperformance0_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }


}

l_doublesplitperformance0_G.high(l_numbers1_G, blackhole, l_splitmethod2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_splitmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_splitmethod2_G.readyTrial) {
                            l_splitmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.set(l_splitmethod2_G, 0);
                    }
                } else {
                    long l_splitmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.get(l_splitmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_splitmethod2_G_backoff);
                        l_splitmethod2_G_backoff = Math.max(1024, l_splitmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_splitmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "high", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_doublesplitperformance0_G.high(l_numbers1_G, blackhole, l_splitmethod2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_splitmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_splitmethod2_G.readyTrial) {
                            l_splitmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.set(l_splitmethod2_G, 0);
                    }
                } else {
                    long l_splitmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.get(l_splitmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_splitmethod2_G_backoff);
                        l_splitmethod2_G_backoff = Math.max(1024, l_splitmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_splitmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "high", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_linearcombinationperformance0_G.fourD(l_factors1_G, blackhole, l_calculator2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.compareAndSet(l_factors1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_factors1_G.readyTrial) {
                            l_factors1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.set(l_factors1_G, 0);
                    }
                } else {
                    long l_factors1_G_backoff = 1;
                    while (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.get(l_factors1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_factors1_G_backoff);
                        l_factors1_G_backoff = Math.max(1024, l_factors1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.compareAndSet(l_calculator2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_calculator2_G.readyTrial) {
                            l_calculator2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.set(l_calculator2_G, 0);
                    }
                } else {
                    long l_calculator2_G_backoff = 1;
                    while (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.get(l_calculator2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_calculator2_G_backoff);
                        l_calculator2_G_backoff = Math.max(1024, l_calculator2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_factors1_G = null;
                }
                synchronized(this.getClass()) {
                    f_calculator2_G = null;
                }
                synchronized(this.getClass()) {
                    f_linearcombinationperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "fourD", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_doublesplitperformance0_G.high(l_numbers1_G, blackhole, l_splitmethod2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_splitmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_splitmethod2_G.readyTrial) {
                            l_splitmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.set(l_splitmethod2_G, 0);
                    }
                } else {
                    long l_splitmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.get(l_splitmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_splitmethod2_G_backoff);
                        l_splitmethod2_G_backoff = Math.max(1024, l_splitmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_splitmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "high", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_doublesplitperformance0_G.high(l_numbers1_G, blackhole, l_splitmethod2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_splitmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_splitmethod2_G.readyTrial) {
                            l_splitmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.set(l_splitmethod2_G, 0);
                    }
                } else {
                    long l_splitmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.get(l_splitmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_splitmethod2_G_backoff);
                        l_splitmethod2_G_backoff = Math.max(1024, l_splitmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_splitmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "high", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_linearcombinationperformance0_G.fourD(l_factors1_G, blackhole, l_calculator2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.compareAndSet(l_factors1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_factors1_G.readyTrial) {
                            l_factors1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.set(l_factors1_G, 0);
                    }
                } else {
                    long l_factors1_G_backoff = 1;
                    while (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.get(l_factors1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_factors1_G_backoff);
                        l_factors1_G_backoff = Math.max(1024, l_factors1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.compareAndSet(l_calculator2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_calculator2_G.readyTrial) {
                            l_calculator2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.set(l_calculator2_G, 0);
                    }
                } else {
                    long l_calculator2_G_backoff = 1;
                    while (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.get(l_calculator2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_calculator2_G_backoff);
                        l_calculator2_G_backoff = Math.max(1024, l_calculator2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_factors1_G = null;
                }
                synchronized(this.getClass()) {
                    f_calculator2_G = null;
                }
                synchronized(this.getClass()) {
                    f_linearcombinationperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "fourD", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_normperformance0_G.baseline(l_vectorarrayinput1_G, blackhole);
        }
        result.stopTime = System.nanoTime();
        result.realTime = realTime;
    }

    
    static volatile NormPerformance_jmhType f_normperformance0_G;
    
    NormPerformance_jmhType _jmh_tryInit_f_normperformance0_G(InfraControl control) throws Throwable {
        NormPerformance_jmhType val = f_normperformance0_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_normperformance0_G;
            if (val != null) {
                return val;
            }
            val = new NormPerformance_jmhType();
            val.readyTrial = true;
            f_normperformance0_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }
    
    static volatile NormPerformance_VectorArrayInput_jmhType f_vectorarrayinput1_G;
    
    NormPerformance_VectorArrayInput_jmhType _jmh_tryInit_f_vectorarrayinput1_G(InfraControl control) throws Throwable {
        NormPerformance_VectorArrayInput_jmhType val = f_vectorarrayinput1_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_vectorarrayinput1_G;
            if (val != null) {
                return val;
            }
            val = new NormPerformance_VectorArrayInput_jmhType();
            Field f;
            f = org.apache.commons.numbers.examples.jmh.core.NormPerformance.VectorArrayInput.class.getDeclaredField("maxExp");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("maxExp")));
            f = org.apache.commons.numbers.examples.jmh.core.NormPerformance.VectorArrayInput.class.getDeclaredField("minExp");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("minExp")));
            f = org.apache.commons.numbers.examples.jmh.core.NormPerformance.VectorArrayInput.class.getDeclaredField("samples");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("samples")));
            f = org.apache.commons.numbers.examples.jmh.core.NormPerformance.VectorArrayInput.class.getDeclaredField("vectorExpRange");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("vectorExpRange")));
            val.createVectors();
            val.readyTrial = true;
            f_vectorarrayinput1_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }


}

l_normperformance0_G.euclidean2d(l_vectorarrayinput2d1_G, blackhole);
        }
        result.stopTime = System.nanoTime();
        result.realTime = realTime;
    }

    
    static volatile NormPerformance_jmhType f_normperformance0_G;
    
    NormPerformance_jmhType _jmh_tryInit_f_normperformance0_G(InfraControl control) throws Throwable {
        NormPerformance_jmhType val = f_normperformance0_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_normperformance0_G;
            if (val != null) {
                return val;
            }
            val = new NormPerformance_jmhType();
            val.readyTrial = true;
            f_normperformance0_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }
    
    static volatile NormPerformance_VectorArrayInput2D_jmhType f_vectorarrayinput2d1_G;
    
    NormPerformance_VectorArrayInput2D_jmhType _jmh_tryInit_f_vectorarrayinput2d1_G(InfraControl control) throws Throwable {
        NormPerformance_VectorArrayInput2D_jmhType val = f_vectorarrayinput2d1_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_vectorarrayinput2d1_G;
            if (val != null) {
                return val;
            }
            val = new NormPerformance_VectorArrayInput2D_jmhType();
            Field f;
            f = org.apache.commons.numbers.examples.jmh.core.NormPerformance.VectorArrayInput.class.getDeclaredField("maxExp");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("maxExp")));
            f = org.apache.commons.numbers.examples.jmh.core.NormPerformance.VectorArrayInput.class.getDeclaredField("minExp");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("minExp")));
            f = org.apache.commons.numbers.examples.jmh.core.NormPerformance.VectorArrayInput.class.getDeclaredField("samples");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("samples")));
            f = org.apache.commons.numbers.examples.jmh.core.NormPerformance.VectorArrayInput.class.getDeclaredField("vectorExpRange");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("vectorExpRange")));
            val.createVectors();
            val.readyTrial = true;
            f_vectorarrayinput2d1_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }


}

l_doublesplitperformance0_G.high(l_numbers1_G, blackhole, l_splitmethod2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_splitmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_splitmethod2_G.readyTrial) {
                            l_splitmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.set(l_splitmethod2_G, 0);
                    }
                } else {
                    long l_splitmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.get(l_splitmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_splitmethod2_G_backoff);
                        l_splitmethod2_G_backoff = Math.max(1024, l_splitmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_splitmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps * batchSize;
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new SampleTimeResult(ResultRole.PRIMARY, "high", buffer, benchmarkParams.getTimeUnit()));

high_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_numbers1_G, l_splitmethod2_G, l_doublesplitperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_doublesplitperformance0_G.high(l_numbers1_G, blackhole, l_splitmethod2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_splitmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_splitmethod2_G.readyTrial) {
                            l_splitmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.set(l_splitmethod2_G, 0);
                    }
                } else {
                    long l_splitmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.get(l_splitmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_splitmethod2_G_backoff);
                        l_splitmethod2_G_backoff = Math.max(1024, l_splitmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_splitmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

nonNormal_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_nonnormalnumbers1_G, l_nonnormalmethod2_G, l_doublesplitperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_doublesplitperformance0_G.nonNormal(l_nonnormalnumbers1_G, blackhole, l_nonnormalmethod2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_NonNormalNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_nonnormalnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_nonnormalnumbers1_G.readyTrial) {
                            l_nonnormalnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_NonNormalNumbers_jmhType.tearTrialMutexUpdater.set(l_nonnormalnumbers1_G, 0);
                    }
                } else {
                    long l_nonnormalnumbers1_G_backoff = 1;
                    while (DoubleSplitPerformance_NonNormalNumbers_jmhType.tearTrialMutexUpdater.get(l_nonnormalnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_nonnormalnumbers1_G_backoff);
                        l_nonnormalnumbers1_G_backoff = Math.max(1024, l_nonnormalnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_NonNormalMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_nonnormalmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_nonnormalmethod2_G.readyTrial) {
                            l_nonnormalmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_NonNormalMethod_jmhType.tearTrialMutexUpdater.set(l_nonnormalmethod2_G, 0);
                    }
                } else {
                    long l_nonnormalmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_NonNormalMethod_jmhType.tearTrialMutexUpdater.get(l_nonnormalmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_nonnormalmethod2_G_backoff);
                        l_nonnormalmethod2_G_backoff = Math.max(1024, l_nonnormalmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_nonnormalnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_nonnormalmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

fourD_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_factors1_G, l_calculator2_G, l_linearcombinationperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_linearcombinationperformance0_G.fourD(l_factors1_G, blackhole, l_calculator2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.compareAndSet(l_factors1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_factors1_G.readyTrial) {
                            l_factors1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.set(l_factors1_G, 0);
                    }
                } else {
                    long l_factors1_G_backoff = 1;
                    while (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.get(l_factors1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_factors1_G_backoff);
                        l_factors1_G_backoff = Math.max(1024, l_factors1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.compareAndSet(l_calculator2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_calculator2_G.readyTrial) {
                            l_calculator2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.set(l_calculator2_G, 0);
                    }
                } else {
                    long l_calculator2_G_backoff = 1;
                    while (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.get(l_calculator2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_calculator2_G_backoff);
                        l_calculator2_G_backoff = Math.max(1024, l_calculator2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_factors1_G = null;
                }
                synchronized(this.getClass()) {
                    f_calculator2_G = null;
                }
                synchronized(this.getClass()) {
                    f_linearcombinationperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

threeD_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_factors1_G, l_calculator2_G, l_linearcombinationperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_linearcombinationperformance0_G.threeD(l_factors1_G, blackhole, l_calculator2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.compareAndSet(l_factors1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_factors1_G.readyTrial) {
                            l_factors1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.set(l_factors1_G, 0);
                    }
                } else {
                    long l_factors1_G_backoff = 1;
                    while (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.get(l_factors1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_factors1_G_backoff);
                        l_factors1_G_backoff = Math.max(1024, l_factors1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.compareAndSet(l_calculator2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_calculator2_G.readyTrial) {
                            l_calculator2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.set(l_calculator2_G, 0);
                    }
                } else {
                    long l_calculator2_G_backoff = 1;
                    while (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.get(l_calculator2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_calculator2_G_backoff);
                        l_calculator2_G_backoff = Math.max(1024, l_calculator2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_factors1_G = null;
                }
                synchronized(this.getClass()) {
                    f_calculator2_G = null;
                }
                synchronized(this.getClass()) {
                    f_linearcombinationperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

stickySum_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_bifactors1_G, l_summethod2_G, l_stickysumperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_stickysumperformance0_G.stickySum(l_bifactors1_G, blackhole, l_summethod2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (StickySumPerformance_BiFactors_jmhType.tearTrialMutexUpdater.compareAndSet(l_bifactors1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_bifactors1_G.readyTrial) {
                            l_bifactors1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        StickySumPerformance_BiFactors_jmhType.tearTrialMutexUpdater.set(l_bifactors1_G, 0);
                    }
                } else {
                    long l_bifactors1_G_backoff = 1;
                    while (StickySumPerformance_BiFactors_jmhType.tearTrialMutexUpdater.get(l_bifactors1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_bifactors1_G_backoff);
                        l_bifactors1_G_backoff = Math.max(1024, l_bifactors1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (StickySumPerformance_SumMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_summethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_summethod2_G.readyTrial) {
                            l_summethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        StickySumPerformance_SumMethod_jmhType.tearTrialMutexUpdater.set(l_summethod2_G, 0);
                    }
                } else {
                    long l_summethod2_G_backoff = 1;
                    while (StickySumPerformance_SumMethod_jmhType.tearTrialMutexUpdater.get(l_summethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_summethod2_G_backoff);
                        l_summethod2_G_backoff = Math.max(1024, l_summethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_bifactors1_G = null;
                }
                synchronized(this.getClass()) {
                    f_summethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_stickysumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

high_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_numbers1_G, l_splitmethod2_G, l_doublesplitperformance0_G);
            control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_splitmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_splitmethod2_G.readyTrial) {
                            l_splitmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.set(l_splitmethod2_G, 0);
                    }
                } else {
                    long l_splitmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.get(l_splitmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_splitmethod2_G_backoff);
                        l_splitmethod2_G_backoff = Math.max(1024, l_splitmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_splitmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }
            int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
            long totalOps = opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
            results.add(new SingleShotResult(ResultRole.PRIMARY, "high", res.getTime(), totalOps, benchmarkParams.getTimeUnit()));

l_doublesplitperformance0_G.high(l_numbers1_G, blackhole, l_splitmethod2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_splitmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_splitmethod2_G.readyTrial) {
                            l_splitmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.set(l_splitmethod2_G, 0);
                    }
                } else {
                    long l_splitmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.get(l_splitmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_splitmethod2_G_backoff);
                        l_splitmethod2_G_backoff = Math.max(1024, l_splitmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_splitmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

l_linearcombinationperformance0_G.fourD(l_factors1_G, blackhole, l_calculator2_G);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.compareAndSet(l_factors1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_factors1_G.readyTrial) {
                            l_factors1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.set(l_factors1_G, 0);
                    }
                } else {
                    long l_factors1_G_backoff = 1;
                    while (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.get(l_factors1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_factors1_G_backoff);
                        l_factors1_G_backoff = Math.max(1024, l_factors1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.compareAndSet(l_calculator2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_calculator2_G.readyTrial) {
                            l_calculator2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.set(l_calculator2_G, 0);
                    }
                } else {
                    long l_calculator2_G_backoff = 1;
                    while (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.get(l_calculator2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_calculator2_G_backoff);
                        l_calculator2_G_backoff = Math.max(1024, l_calculator2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_factors1_G = null;
                }
                synchronized(this.getClass()) {
                    f_calculator2_G = null;
                }
                synchronized(this.getClass()) {
                    f_linearcombinationperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps * batchSize;

l_euclideannormalgorithmperformance0_G.direct(l_vectorarrayinput1_G, blackhole);
        }
        result.stopTime = System.nanoTime();
        result.realTime = realTime;
    }

    
    static volatile EuclideanNormAlgorithmPerformance_jmhType f_euclideannormalgorithmperformance0_G;
    
    EuclideanNormAlgorithmPerformance_jmhType _jmh_tryInit_f_euclideannormalgorithmperformance0_G(InfraControl control) throws Throwable {
        EuclideanNormAlgorithmPerformance_jmhType val = f_euclideannormalgorithmperformance0_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_euclideannormalgorithmperformance0_G;
            if (val != null) {
                return val;
            }
            val = new EuclideanNormAlgorithmPerformance_jmhType();
            val.readyTrial = true;
            f_euclideannormalgorithmperformance0_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }
    
    static volatile EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType f_vectorarrayinput1_G;
    
    EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType _jmh_tryInit_f_vectorarrayinput1_G(InfraControl control) throws Throwable {
        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType val = f_vectorarrayinput1_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_vectorarrayinput1_G;
            if (val != null) {
                return val;
            }
            val = new EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType();
            Field f;
            f = org.apache.commons.numbers.examples.jmh.core.EuclideanNormAlgorithmPerformance.VectorArrayInput.class.getDeclaredField("samples");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("samples")));
            f = org.apache.commons.numbers.examples.jmh.core.EuclideanNormAlgorithmPerformance.VectorArrayInput.class.getDeclaredField("type");
            f.setAccessible(true);
            f.set(val, control.getParam("type"));
            f = org.apache.commons.numbers.examples.jmh.core.EuclideanNormAlgorithmPerformance.VectorArrayInput.class.getDeclaredField("vectorLength");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("vectorLength")));
            val.createVectors();
            val.readyTrial = true;
            f_vectorarrayinput1_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }


}

static final class ExtendedPrecisionLinearCombinationSinglePass implements ToDoubleFunction<double[]> {

        /** Threshold for scaling small numbers. */
        private static final double SMALL_THRESH = 0x1.0p-500;

        /** Threshold for scaling large numbers. */
        private static final double LARGE_THRESH = 0x1.0p+500;

        /** Value used to scale down large numbers. */
        private static final double SCALE_DOWN = 0x1.0p-600;

        /** Value used to scale up small numbers. */
        private static final double SCALE_UP = 0x1.0p+600;

        /** {@inheritDoc} */
        @Override
        public double applyAsDouble(final double[] v) {
            double s1 = 0;
            double s2 = 0;
            double s3 = 0;
            double c1 = 0;
            double c2 = 0;
            double c3 = 0;
            for (int i = 0; i < v.length; ++i) {
                final double x = Math.abs(v[i]);
                if (Double.isNaN(x)) {
                    // found an NaN; no use in continuing
                    return x;
                } else if (x > LARGE_THRESH) {
                    // scale down
                    final double sx = x * SCALE_DOWN;

                    // compute the product and product correction
                    final double p = sx * sx;
                    final double cp = productLowUnscaled(sx, p);

                    // compute the running sum and sum correction
                    final double s = s1 + p;
                    final double cs = DoublePrecision.twoSumLow(s1, p, s);

                    // update running totals
                    c1 += cp + cs;
                    s1 = s;
                } else if (x < SMALL_THRESH) {
                    // scale up
                    final double sx = x * SCALE_UP;

                    // compute the product and product correction
                    final double p = sx * sx;
                    final double cp = productLowUnscaled(sx, p);

                    // compute the running sum and sum correction
                    final double s = s3 + p;
                    final double cs = DoublePrecision.twoSumLow(s3, p, s);

                    // update running totals
                    c3 += cp + cs;
                    s3 = s;
                } else {
                    // no scaling
                    // compute the product and product correction
                    final double p = x * x;
                    final double cp = productLowUnscaled(x, p);

                    // compute the running sum and sum correction
                    final double s = s2 + p;
                    final double cs = DoublePrecision.twoSumLow(s2, p, s);

                    // update running totals
                    c2 += cp + cs;
                    s2 = s;
                }
            }

            if (s1 != 0) {
                // add s1, s2, c1, c2
                s2 = s2 * SCALE_DOWN * SCALE_DOWN;
                c2 = c2 * SCALE_DOWN * SCALE_DOWN;
                final double sum = s1 + s2;
                c1 += DoublePrecision.twoSumLow(s1, s2, sum) + c2;

control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (DoubleSplitPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_splitmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_splitmethod2_G.readyTrial) {
                            l_splitmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.set(l_splitmethod2_G, 0);
                    }
                } else {
                    long l_splitmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_SplitMethod_jmhType.tearTrialMutexUpdater.get(l_splitmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_splitmethod2_G_backoff);
                        l_splitmethod2_G_backoff = Math.max(1024, l_splitmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_splitmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }

control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_NonNormalNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_nonnormalnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_nonnormalnumbers1_G.readyTrial) {
                            l_nonnormalnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_NonNormalNumbers_jmhType.tearTrialMutexUpdater.set(l_nonnormalnumbers1_G, 0);
                    }
                } else {
                    long l_nonnormalnumbers1_G_backoff = 1;
                    while (DoubleSplitPerformance_NonNormalNumbers_jmhType.tearTrialMutexUpdater.get(l_nonnormalnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_nonnormalnumbers1_G_backoff);
                        l_nonnormalnumbers1_G_backoff = Math.max(1024, l_nonnormalnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_NonNormalMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_nonnormalmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_nonnormalmethod2_G.readyTrial) {
                            l_nonnormalmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_NonNormalMethod_jmhType.tearTrialMutexUpdater.set(l_nonnormalmethod2_G, 0);
                    }
                } else {
                    long l_nonnormalmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_NonNormalMethod_jmhType.tearTrialMutexUpdater.get(l_nonnormalmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_nonnormalmethod2_G_backoff);
                        l_nonnormalmethod2_G_backoff = Math.max(1024, l_nonnormalmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_nonnormalnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_nonnormalmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }

control.preTearDown();

            if (control.isLastIteration()) {
                if (DoubleSplitPerformance_BiFactors_jmhType.tearTrialMutexUpdater.compareAndSet(l_bifactors1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_bifactors1_G.readyTrial) {
                            l_bifactors1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_BiFactors_jmhType.tearTrialMutexUpdater.set(l_bifactors1_G, 0);
                    }
                } else {
                    long l_bifactors1_G_backoff = 1;
                    while (DoubleSplitPerformance_BiFactors_jmhType.tearTrialMutexUpdater.get(l_bifactors1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_bifactors1_G_backoff);
                        l_bifactors1_G_backoff = Math.max(1024, l_bifactors1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (DoubleSplitPerformance_RoundoffMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_roundoffmethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_roundoffmethod2_G.readyTrial) {
                            l_roundoffmethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        DoubleSplitPerformance_RoundoffMethod_jmhType.tearTrialMutexUpdater.set(l_roundoffmethod2_G, 0);
                    }
                } else {
                    long l_roundoffmethod2_G_backoff = 1;
                    while (DoubleSplitPerformance_RoundoffMethod_jmhType.tearTrialMutexUpdater.get(l_roundoffmethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_roundoffmethod2_G_backoff);
                        l_roundoffmethod2_G_backoff = Math.max(1024, l_roundoffmethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_bifactors1_G = null;
                }
                synchronized(this.getClass()) {
                    f_roundoffmethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_doublesplitperformance0_G = null;
                }
            }

control.preTearDown();

            if (control.isLastIteration()) {
                if (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.compareAndSet(l_factors1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_factors1_G.readyTrial) {
                            l_factors1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.set(l_factors1_G, 0);
                    }
                } else {
                    long l_factors1_G_backoff = 1;
                    while (LinearCombinationPerformance_Factors_jmhType.tearTrialMutexUpdater.get(l_factors1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_factors1_G_backoff);
                        l_factors1_G_backoff = Math.max(1024, l_factors1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.compareAndSet(l_calculator2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_calculator2_G.readyTrial) {
                            l_calculator2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.set(l_calculator2_G, 0);
                    }
                } else {
                    long l_calculator2_G_backoff = 1;
                    while (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.get(l_calculator2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_calculator2_G_backoff);
                        l_calculator2_G_backoff = Math.max(1024, l_calculator2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_factors1_G = null;
                }
                synchronized(this.getClass()) {
                    f_calculator2_G = null;
                }
                synchronized(this.getClass()) {
                    f_linearcombinationperformance0_G = null;
                }
            }

control.preTearDown();

            if (control.isLastIteration()) {
                if (LinearCombinationPerformance_LengthFactors_jmhType.tearTrialMutexUpdater.compareAndSet(l_lengthfactors1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_lengthfactors1_G.readyTrial) {
                            l_lengthfactors1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_LengthFactors_jmhType.tearTrialMutexUpdater.set(l_lengthfactors1_G, 0);
                    }
                } else {
                    long l_lengthfactors1_G_backoff = 1;
                    while (LinearCombinationPerformance_LengthFactors_jmhType.tearTrialMutexUpdater.get(l_lengthfactors1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_lengthfactors1_G_backoff);
                        l_lengthfactors1_G_backoff = Math.max(1024, l_lengthfactors1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.compareAndSet(l_calculator2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_calculator2_G.readyTrial) {
                            l_calculator2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.set(l_calculator2_G, 0);
                    }
                } else {
                    long l_calculator2_G_backoff = 1;
                    while (LinearCombinationPerformance_Calculator_jmhType.tearTrialMutexUpdater.get(l_calculator2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_calculator2_G_backoff);
                        l_calculator2_G_backoff = Math.max(1024, l_calculator2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_lengthfactors1_G = null;
                }
                synchronized(this.getClass()) {
                    f_calculator2_G = null;
                }
                synchronized(this.getClass()) {
                    f_linearcombinationperformance0_G = null;
                }
            }

control.preTearDown();

            if (control.isLastIteration()) {
                if (StickySumPerformance_BiFactors_jmhType.tearTrialMutexUpdater.compareAndSet(l_bifactors1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_bifactors1_G.readyTrial) {
                            l_bifactors1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        StickySumPerformance_BiFactors_jmhType.tearTrialMutexUpdater.set(l_bifactors1_G, 0);
                    }
                } else {
                    long l_bifactors1_G_backoff = 1;
                    while (StickySumPerformance_BiFactors_jmhType.tearTrialMutexUpdater.get(l_bifactors1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_bifactors1_G_backoff);
                        l_bifactors1_G_backoff = Math.max(1024, l_bifactors1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                if (StickySumPerformance_SumMethod_jmhType.tearTrialMutexUpdater.compareAndSet(l_summethod2_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_summethod2_G.readyTrial) {
                            l_summethod2_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        StickySumPerformance_SumMethod_jmhType.tearTrialMutexUpdater.set(l_summethod2_G, 0);
                    }
                } else {
                    long l_summethod2_G_backoff = 1;
                    while (StickySumPerformance_SumMethod_jmhType.tearTrialMutexUpdater.get(l_summethod2_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_summethod2_G_backoff);
                        l_summethod2_G_backoff = Math.max(1024, l_summethod2_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_bifactors1_G = null;
                }
                synchronized(this.getClass()) {
                    f_summethod2_G = null;
                }
                synchronized(this.getClass()) {
                    f_stickysumperformance0_G = null;
                }
            }

l_complexperformance0_G.add(l_twocomplexnumbers1_G, blackhole);
        }
        result.stopTime = System.nanoTime();
        result.realTime = realTime;
    }

    
    static volatile ComplexPerformance_jmhType f_complexperformance0_G;
    
    ComplexPerformance_jmhType _jmh_tryInit_f_complexperformance0_G(InfraControl control) throws Throwable {
        ComplexPerformance_jmhType val = f_complexperformance0_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_complexperformance0_G;
            if (val != null) {
                return val;
            }
            val = new ComplexPerformance_jmhType();
            val.readyTrial = true;
            f_complexperformance0_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }
    
    static volatile ComplexPerformance_TwoComplexNumbers_jmhType f_twocomplexnumbers1_G;
    
    ComplexPerformance_TwoComplexNumbers_jmhType _jmh_tryInit_f_twocomplexnumbers1_G(InfraControl control) throws Throwable {
        ComplexPerformance_TwoComplexNumbers_jmhType val = f_twocomplexnumbers1_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_twocomplexnumbers1_G;
            if (val != null) {
                return val;
            }
            val = new ComplexPerformance_TwoComplexNumbers_jmhType();
            Field f;
            f = org.apache.commons.numbers.examples.jmh.complex.ComplexPerformance.ComplexNumberSize.class.getDeclaredField("size");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("size")));
            f = org.apache.commons.numbers.examples.jmh.complex.ComplexPerformance.ComplexNumbers.class.getDeclaredField("type");
            f.setAccessible(true);
            f.set(val, control.getParam("type"));
            val.setup();
            val.setup();
            val.readyTrial = true;
            f_twocomplexnumbers1_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }


}

l_sincosperformance0_G.rangeFastMathSin(l_uniformnumbers1_G, blackhole);
        }
        result.stopTime = System.nanoTime();
        result.realTime = realTime;
    }

    
    static volatile SinCosPerformance_jmhType f_sincosperformance0_G;
    
    SinCosPerformance_jmhType _jmh_tryInit_f_sincosperformance0_G(InfraControl control) throws Throwable {
        SinCosPerformance_jmhType val = f_sincosperformance0_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_sincosperformance0_G;
            if (val != null) {
                return val;
            }
            val = new SinCosPerformance_jmhType();
            val.readyTrial = true;
            f_sincosperformance0_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }
    
    static volatile SinCosPerformance_UniformNumbers_jmhType f_uniformnumbers1_G;
    
    SinCosPerformance_UniformNumbers_jmhType _jmh_tryInit_f_uniformnumbers1_G(InfraControl control) throws Throwable {
        SinCosPerformance_UniformNumbers_jmhType val = f_uniformnumbers1_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_uniformnumbers1_G;
            if (val != null) {
                return val;
            }
            val = new SinCosPerformance_UniformNumbers_jmhType();
            Field f;
            f = org.apache.commons.numbers.examples.jmh.complex.SinCosPerformance.UniformNumbers.class.getDeclaredField("range");
            f.setAccessible(true);
            f.set(val, Double.valueOf(control.getParam("range")));
            f = org.apache.commons.numbers.examples.jmh.complex.SinCosPerformance.NumberSize.class.getDeclaredField("size");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("size")));
            val.setup();
            val.readyTrial = true;
            f_uniformnumbers1_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }


}

absMathHypot_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.absMathHypot(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "absMathHypot", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

abs_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.abs(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "abs", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

acos_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.acos(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "acos", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

acosh_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.acosh(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "acosh", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

addReal_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexandrealnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.addReal(l_complexandrealnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "addReal", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

add_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_twocomplexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.add(l_twocomplexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_twocomplexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_twocomplexnumbers1_G.readyTrial) {
                            l_twocomplexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_twocomplexnumbers1_G, 0);
                    }
                } else {
                    long l_twocomplexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_twocomplexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_twocomplexnumbers1_G_backoff);
                        l_twocomplexnumbers1_G_backoff = Math.max(1024, l_twocomplexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_twocomplexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "add", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

arg_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.arg(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "arg", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

asin_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.asin(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "asin", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

asinh_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.asinh(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "asinh", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

atan_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.atan(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "atan", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

atanh_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.atanh(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "atanh", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

baselineCopy_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.baselineCopy(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "baselineCopy", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

baselineIdentity_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.baselineIdentity(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "baselineIdentity", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

conj_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.conj(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "conj", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

cos_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.cos(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "cos", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

cosh_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.cosh(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "cosh", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

divideReal_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexandrealnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.divideReal(l_complexandrealnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "divideReal", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

divide_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_twocomplexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.divide(l_twocomplexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_twocomplexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_twocomplexnumbers1_G.readyTrial) {
                            l_twocomplexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_twocomplexnumbers1_G, 0);
                    }
                } else {
                    long l_twocomplexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_twocomplexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_twocomplexnumbers1_G_backoff);
                        l_twocomplexnumbers1_G_backoff = Math.max(1024, l_twocomplexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_twocomplexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "divide", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

exp_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.exp(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "exp", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

imag_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.imag(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "imag", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

isFinite_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.isFinite(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "isFinite", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

isInfinite_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.isInfinite(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "isInfinite", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

isNaN_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.isNaN(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "isNaN", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

log10_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.log10(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "log10", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

log_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.log(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "log", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

multiplyReal_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexandrealnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.multiplyReal(l_complexandrealnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "multiplyReal", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

multiply_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_twocomplexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.multiply(l_twocomplexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_twocomplexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_twocomplexnumbers1_G.readyTrial) {
                            l_twocomplexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_twocomplexnumbers1_G, 0);
                    }
                } else {
                    long l_twocomplexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_twocomplexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_twocomplexnumbers1_G_backoff);
                        l_twocomplexnumbers1_G_backoff = Math.max(1024, l_twocomplexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_twocomplexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "multiply", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

negate_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.negate(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "negate", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

norm_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.norm(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "norm", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

powReal_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexandrealnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.powReal(l_complexandrealnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "powReal", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

pow_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_twocomplexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.pow(l_twocomplexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_twocomplexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_twocomplexnumbers1_G.readyTrial) {
                            l_twocomplexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_twocomplexnumbers1_G, 0);
                    }
                } else {
                    long l_twocomplexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_twocomplexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_twocomplexnumbers1_G_backoff);
                        l_twocomplexnumbers1_G_backoff = Math.max(1024, l_twocomplexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_twocomplexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "pow", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

proj_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.proj(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "proj", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

real_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.real(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "real", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

sin_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.sin(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "sin", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

sinh_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.sinh(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "sinh", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

sqrtNorm_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.sqrtNorm(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "sqrtNorm", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

sqrt_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.sqrt(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "sqrt", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

subtractReal_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexandrealnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.subtractReal(l_complexandrealnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "subtractReal", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

subtract_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_twocomplexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.subtract(l_twocomplexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_twocomplexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_twocomplexnumbers1_G.readyTrial) {
                            l_twocomplexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_twocomplexnumbers1_G, 0);
                    }
                } else {
                    long l_twocomplexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_twocomplexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_twocomplexnumbers1_G_backoff);
                        l_twocomplexnumbers1_G_backoff = Math.max(1024, l_twocomplexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_twocomplexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "subtract", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

tan_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.tan(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "tan", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

tanh_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.tanh(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "tanh", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

baselineIdentity_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_numbers1_G, l_sincosperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sincosperformance0_G.baselineIdentity(l_numbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "baselineIdentity", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

fastMathCos_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_numbers1_G, l_sincosperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sincosperformance0_G.fastMathCos(l_numbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "fastMathCos", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

fastMathSin_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_numbers1_G, l_sincosperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sincosperformance0_G.fastMathSin(l_numbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "fastMathSin", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

mathCos_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_numbers1_G, l_sincosperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sincosperformance0_G.mathCos(l_numbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "mathCos", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

mathSin_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_numbers1_G, l_sincosperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sincosperformance0_G.mathSin(l_numbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "mathSin", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

rangeFastMathSin_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_uniformnumbers1_G, l_sincosperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sincosperformance0_G.rangeFastMathSin(l_uniformnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_uniformnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_uniformnumbers1_G.readyTrial) {
                            l_uniformnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.set(l_uniformnumbers1_G, 0);
                    }
                } else {
                    long l_uniformnumbers1_G_backoff = 1;
                    while (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.get(l_uniformnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_uniformnumbers1_G_backoff);
                        l_uniformnumbers1_G_backoff = Math.max(1024, l_uniformnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_uniformnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "rangeFastMathSin", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

rangeMathSin_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_uniformnumbers1_G, l_sincosperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sincosperformance0_G.rangeMathSin(l_uniformnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_uniformnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_uniformnumbers1_G.readyTrial) {
                            l_uniformnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.set(l_uniformnumbers1_G, 0);
                    }
                } else {
                    long l_uniformnumbers1_G_backoff = 1;
                    while (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.get(l_uniformnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_uniformnumbers1_G_backoff);
                        l_uniformnumbers1_G_backoff = Math.max(1024, l_uniformnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_uniformnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "rangeMathSin", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

direct_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.direct(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "direct", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

enormModExt_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.enormModExt(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "enormModExt", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

enormModKahan_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.enormModKahan(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "enormModKahan", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

enormMod_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.enormMod(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "enormMod", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

enorm_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.enorm(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "enorm", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

exact_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.exact(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "exact", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

extLinearMod_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.extLinearMod(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "extLinearMod", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

extLinearSinglePass_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.extLinearSinglePass(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "extLinearSinglePass", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

extLinearSqrt2_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.extLinearSqrt2(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "extLinearSqrt2", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

extLinear_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.extLinear(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "extLinear", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

baseline_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_normperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_normperformance0_G.baseline(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "baseline", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

directEuclideanArray_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_normperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_normperformance0_G.directEuclideanArray(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "directEuclideanArray", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

euclidean2d_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput2d1_G, l_normperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_normperformance0_G.euclidean2d(l_vectorarrayinput2d1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput2d1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput2d1_G.readyTrial) {
                            l_vectorarrayinput2d1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput2d1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput2d1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput2d1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput2d1_G_backoff);
                        l_vectorarrayinput2d1_G_backoff = Math.max(1024, l_vectorarrayinput2d1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput2d1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "euclidean2d", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

euclidean3d_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_normperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_normperformance0_G.euclidean3d(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "euclidean3d", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

euclideanArray_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_normperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_normperformance0_G.euclideanArray(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "euclideanArray", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

hypot_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput2d1_G, l_normperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_normperformance0_G.hypot(l_vectorarrayinput2d1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput2d1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput2d1_G.readyTrial) {
                            l_vectorarrayinput2d1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput2d1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput2d1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput2d1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput2d1_G_backoff);
                        l_vectorarrayinput2d1_G_backoff = Math.max(1024, l_vectorarrayinput2d1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput2d1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "hypot", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

baselineDouble_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_arrayinput1_G, l_sumperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sumperformance0_G.baselineDouble(l_arrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "baselineDouble", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

baselineSingle_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_arrayinput1_G, l_sumperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sumperformance0_G.baselineSingle(l_arrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "baselineSingle", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

sumOfProducts_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_arrayinput1_G, l_sumperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sumperformance0_G.sumOfProducts(l_arrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "sumOfProducts", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

sum_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_arrayinput1_G, l_sumperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sumperformance0_G.sum(l_arrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "sum", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

baseline_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_basedata1_G, l_erfperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_erfperformance0_G.baseline(l_basedata1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ErfPerformance_BaseData_jmhType.tearTrialMutexUpdater.compareAndSet(l_basedata1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_basedata1_G.readyTrial) {
                            l_basedata1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ErfPerformance_BaseData_jmhType.tearTrialMutexUpdater.set(l_basedata1_G, 0);
                    }
                } else {
                    long l_basedata1_G_backoff = 1;
                    while (ErfPerformance_BaseData_jmhType.tearTrialMutexUpdater.get(l_basedata1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_basedata1_G_backoff);
                        l_basedata1_G_backoff = Math.max(1024, l_basedata1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_basedata1_G = null;
                }
                synchronized(this.getClass()) {
                    f_erfperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "baseline", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

erf_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_erfdata1_G, l_erfperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_erfperformance0_G.erf(l_erfdata1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ErfPerformance_ErfData_jmhType.tearTrialMutexUpdater.compareAndSet(l_erfdata1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_erfdata1_G.readyTrial) {
                            l_erfdata1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ErfPerformance_ErfData_jmhType.tearTrialMutexUpdater.set(l_erfdata1_G, 0);
                    }
                } else {
                    long l_erfdata1_G_backoff = 1;
                    while (ErfPerformance_ErfData_jmhType.tearTrialMutexUpdater.get(l_erfdata1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_erfdata1_G_backoff);
                        l_erfdata1_G_backoff = Math.max(1024, l_erfdata1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_erfdata1_G = null;
                }
                synchronized(this.getClass()) {
                    f_erfperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "erf", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

erfc_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_erfcdata1_G, l_erfperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_erfperformance0_G.erfc(l_erfcdata1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ErfPerformance_ErfcData_jmhType.tearTrialMutexUpdater.compareAndSet(l_erfcdata1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_erfcdata1_G.readyTrial) {
                            l_erfcdata1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ErfPerformance_ErfcData_jmhType.tearTrialMutexUpdater.set(l_erfcdata1_G, 0);
                    }
                } else {
                    long l_erfcdata1_G_backoff = 1;
                    while (ErfPerformance_ErfcData_jmhType.tearTrialMutexUpdater.get(l_erfcdata1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_erfcdata1_G_backoff);
                        l_erfcdata1_G_backoff = Math.max(1024, l_erfcdata1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_erfcdata1_G = null;
                }
                synchronized(this.getClass()) {
                    f_erfperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "erfc", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

inverseErf_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_inverseerfdata1_G, l_erfperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_erfperformance0_G.inverseErf(l_inverseerfdata1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ErfPerformance_InverseErfData_jmhType.tearTrialMutexUpdater.compareAndSet(l_inverseerfdata1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_inverseerfdata1_G.readyTrial) {
                            l_inverseerfdata1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ErfPerformance_InverseErfData_jmhType.tearTrialMutexUpdater.set(l_inverseerfdata1_G, 0);
                    }
                } else {
                    long l_inverseerfdata1_G_backoff = 1;
                    while (ErfPerformance_InverseErfData_jmhType.tearTrialMutexUpdater.get(l_inverseerfdata1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_inverseerfdata1_G_backoff);
                        l_inverseerfdata1_G_backoff = Math.max(1024, l_inverseerfdata1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_inverseerfdata1_G = null;
                }
                synchronized(this.getClass()) {
                    f_erfperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "inverseErf", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

inverseErfc_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_inverseerfcdata1_G, l_erfperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_erfperformance0_G.inverseErfc(l_inverseerfcdata1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ErfPerformance_InverseErfcData_jmhType.tearTrialMutexUpdater.compareAndSet(l_inverseerfcdata1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_inverseerfcdata1_G.readyTrial) {
                            l_inverseerfcdata1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ErfPerformance_InverseErfcData_jmhType.tearTrialMutexUpdater.set(l_inverseerfcdata1_G, 0);
                    }
                } else {
                    long l_inverseerfcdata1_G_backoff = 1;
                    while (ErfPerformance_InverseErfcData_jmhType.tearTrialMutexUpdater.get(l_inverseerfcdata1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_inverseerfcdata1_G_backoff);
                        l_inverseerfcdata1_G_backoff = Math.max(1024, l_inverseerfcdata1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_inverseerfcdata1_G = null;
                }
                synchronized(this.getClass()) {
                    f_erfperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "inverseErfc", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

evaluate_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_basedata1_G, l_gammacontinuedfractionperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_gammacontinuedfractionperformance0_G.evaluate(l_basedata1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (GammaContinuedFractionPerformance_BaseData_jmhType.tearTrialMutexUpdater.compareAndSet(l_basedata1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_basedata1_G.readyTrial) {
                            l_basedata1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        GammaContinuedFractionPerformance_BaseData_jmhType.tearTrialMutexUpdater.set(l_basedata1_G, 0);
                    }
                } else {
                    long l_basedata1_G_backoff = 1;
                    while (GammaContinuedFractionPerformance_BaseData_jmhType.tearTrialMutexUpdater.get(l_basedata1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_basedata1_G_backoff);
                        l_basedata1_G_backoff = Math.max(1024, l_basedata1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_basedata1_G = null;
                }
                synchronized(this.getClass()) {
                    f_gammacontinuedfractionperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "evaluate", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_sincosperformance0_G.baselineIdentity(l_numbers1_G, blackhole);
        }
        result.stopTime = System.nanoTime();
        result.realTime = realTime;
    }

    
    static volatile SinCosPerformance_Numbers_jmhType f_numbers1_G;
    
    SinCosPerformance_Numbers_jmhType _jmh_tryInit_f_numbers1_G(InfraControl control) throws Throwable {
        SinCosPerformance_Numbers_jmhType val = f_numbers1_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_numbers1_G;
            if (val != null) {
                return val;
            }
            val = new SinCosPerformance_Numbers_jmhType();
            Field f;
            f = org.apache.commons.numbers.examples.jmh.complex.SinCosPerformance.NumberSize.class.getDeclaredField("size");
            f.setAccessible(true);
            f.set(val, Integer.valueOf(control.getParam("size")));
            f = org.apache.commons.numbers.examples.jmh.complex.SinCosPerformance.Numbers.class.getDeclaredField("type");
            f.setAccessible(true);
            f.set(val, control.getParam("type"));
            val.setup();
            val.readyTrial = true;
            f_numbers1_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }
    
    static volatile SinCosPerformance_jmhType f_sincosperformance0_G;
    
    SinCosPerformance_jmhType _jmh_tryInit_f_sincosperformance0_G(InfraControl control) throws Throwable {
        SinCosPerformance_jmhType val = f_sincosperformance0_G;
        if (val != null) {
            return val;
        }
        synchronized(this.getClass()) {
            try {
            if (control.isFailing) throw new FailureAssistException();
            val = f_sincosperformance0_G;
            if (val != null) {
                return val;
            }
            val = new SinCosPerformance_jmhType();
            val.readyTrial = true;
            f_sincosperformance0_G = val;
            } catch (Throwable t) {
                control.isFailing = true;
                throw t;
            }
        }
        return val;
    }


}

l_complexperformance0_G.absMathHypot(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "absMathHypot", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_complexperformance0_G.addReal(l_complexandrealnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "addReal", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_complexperformance0_G.add(l_twocomplexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_twocomplexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_twocomplexnumbers1_G.readyTrial) {
                            l_twocomplexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_twocomplexnumbers1_G, 0);
                    }
                } else {
                    long l_twocomplexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_twocomplexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_twocomplexnumbers1_G_backoff);
                        l_twocomplexnumbers1_G_backoff = Math.max(1024, l_twocomplexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_twocomplexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "add", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_sincosperformance0_G.baselineIdentity(l_numbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "baselineIdentity", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_sincosperformance0_G.rangeFastMathSin(l_uniformnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_uniformnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_uniformnumbers1_G.readyTrial) {
                            l_uniformnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.set(l_uniformnumbers1_G, 0);
                    }
                } else {
                    long l_uniformnumbers1_G_backoff = 1;
                    while (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.get(l_uniformnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_uniformnumbers1_G_backoff);
                        l_uniformnumbers1_G_backoff = Math.max(1024, l_uniformnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_uniformnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "rangeFastMathSin", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_sincosperformance0_G.rangeFastMathSin(l_uniformnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_uniformnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_uniformnumbers1_G.readyTrial) {
                            l_uniformnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.set(l_uniformnumbers1_G, 0);
                    }
                } else {
                    long l_uniformnumbers1_G_backoff = 1;
                    while (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.get(l_uniformnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_uniformnumbers1_G_backoff);
                        l_uniformnumbers1_G_backoff = Math.max(1024, l_uniformnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_uniformnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "rangeFastMathSin", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_euclideannormalgorithmperformance0_G.direct(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "direct", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_euclideannormalgorithmperformance0_G.direct(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "direct", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_normperformance0_G.baseline(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "baseline", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_normperformance0_G.baseline(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "baseline", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_normperformance0_G.euclidean2d(l_vectorarrayinput2d1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput2d1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput2d1_G.readyTrial) {
                            l_vectorarrayinput2d1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput2d1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput2d1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput2d1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput2d1_G_backoff);
                        l_vectorarrayinput2d1_G_backoff = Math.max(1024, l_vectorarrayinput2d1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput2d1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "euclidean2d", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_normperformance0_G.euclidean2d(l_vectorarrayinput2d1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput2d1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput2d1_G.readyTrial) {
                            l_vectorarrayinput2d1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput2d1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput2d1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput2d1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput2d1_G_backoff);
                        l_vectorarrayinput2d1_G_backoff = Math.max(1024, l_vectorarrayinput2d1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput2d1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "euclidean2d", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_sumperformance0_G.baselineDouble(l_arrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "baselineDouble", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_sumperformance0_G.baselineDouble(l_arrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "baselineDouble", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_complexperformance0_G.absMathHypot(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "absMathHypot", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_complexperformance0_G.addReal(l_complexandrealnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "addReal", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_complexperformance0_G.add(l_twocomplexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_twocomplexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_twocomplexnumbers1_G.readyTrial) {
                            l_twocomplexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_twocomplexnumbers1_G, 0);
                    }
                } else {
                    long l_twocomplexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_twocomplexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_twocomplexnumbers1_G_backoff);
                        l_twocomplexnumbers1_G_backoff = Math.max(1024, l_twocomplexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_twocomplexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "add", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_sincosperformance0_G.baselineIdentity(l_numbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "baselineIdentity", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_sincosperformance0_G.rangeFastMathSin(l_uniformnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_uniformnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_uniformnumbers1_G.readyTrial) {
                            l_uniformnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.set(l_uniformnumbers1_G, 0);
                    }
                } else {
                    long l_uniformnumbers1_G_backoff = 1;
                    while (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.get(l_uniformnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_uniformnumbers1_G_backoff);
                        l_uniformnumbers1_G_backoff = Math.max(1024, l_uniformnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_uniformnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "rangeFastMathSin", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_sincosperformance0_G.rangeFastMathSin(l_uniformnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_uniformnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_uniformnumbers1_G.readyTrial) {
                            l_uniformnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.set(l_uniformnumbers1_G, 0);
                    }
                } else {
                    long l_uniformnumbers1_G_backoff = 1;
                    while (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.get(l_uniformnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_uniformnumbers1_G_backoff);
                        l_uniformnumbers1_G_backoff = Math.max(1024, l_uniformnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_uniformnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "rangeFastMathSin", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_euclideannormalgorithmperformance0_G.direct(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "direct", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_euclideannormalgorithmperformance0_G.direct(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "direct", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_normperformance0_G.baseline(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "baseline", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_normperformance0_G.baseline(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "baseline", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_normperformance0_G.euclidean2d(l_vectorarrayinput2d1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput2d1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput2d1_G.readyTrial) {
                            l_vectorarrayinput2d1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput2d1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput2d1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput2d1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput2d1_G_backoff);
                        l_vectorarrayinput2d1_G_backoff = Math.max(1024, l_vectorarrayinput2d1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput2d1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "euclidean2d", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_normperformance0_G.euclidean2d(l_vectorarrayinput2d1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput2d1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput2d1_G.readyTrial) {
                            l_vectorarrayinput2d1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput2d1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput2d1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput2d1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput2d1_G_backoff);
                        l_vectorarrayinput2d1_G_backoff = Math.max(1024, l_vectorarrayinput2d1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput2d1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "euclidean2d", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_sumperformance0_G.baselineDouble(l_arrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new ThroughputResult(ResultRole.PRIMARY, "baselineDouble", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_sumperformance0_G.baselineDouble(l_arrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;
            int batchSize = iterationParams.getBatchSize();
            int opsPerInv = benchmarkParams.getOpsPerInvocation();
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            res.measuredOps /= batchSize;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new AverageTimeResult(ResultRole.PRIMARY, "baselineDouble", res.measuredOps, res.getTime(), benchmarkParams.getTimeUnit()));

l_complexperformance0_G.addReal(l_complexandrealnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps * batchSize;
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new SampleTimeResult(ResultRole.PRIMARY, "addReal", buffer, benchmarkParams.getTimeUnit()));

l_sincosperformance0_G.baselineIdentity(l_numbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps * batchSize;
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new SampleTimeResult(ResultRole.PRIMARY, "baselineIdentity", buffer, benchmarkParams.getTimeUnit()));

l_sincosperformance0_G.rangeFastMathSin(l_uniformnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_uniformnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_uniformnumbers1_G.readyTrial) {
                            l_uniformnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.set(l_uniformnumbers1_G, 0);
                    }
                } else {
                    long l_uniformnumbers1_G_backoff = 1;
                    while (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.get(l_uniformnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_uniformnumbers1_G_backoff);
                        l_uniformnumbers1_G_backoff = Math.max(1024, l_uniformnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_uniformnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps * batchSize;
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new SampleTimeResult(ResultRole.PRIMARY, "rangeFastMathSin", buffer, benchmarkParams.getTimeUnit()));

l_euclideannormalgorithmperformance0_G.direct(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps * batchSize;
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new SampleTimeResult(ResultRole.PRIMARY, "direct", buffer, benchmarkParams.getTimeUnit()));

l_normperformance0_G.baseline(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps * batchSize;
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new SampleTimeResult(ResultRole.PRIMARY, "baseline", buffer, benchmarkParams.getTimeUnit()));

l_normperformance0_G.euclidean2d(l_vectorarrayinput2d1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput2d1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput2d1_G.readyTrial) {
                            l_vectorarrayinput2d1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput2d1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput2d1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput2d1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput2d1_G_backoff);
                        l_vectorarrayinput2d1_G_backoff = Math.max(1024, l_vectorarrayinput2d1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput2d1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps * batchSize;
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new SampleTimeResult(ResultRole.PRIMARY, "euclidean2d", buffer, benchmarkParams.getTimeUnit()));

l_sumperformance0_G.baselineDouble(l_arrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps * batchSize;
            res.allOps *= opsPerInv;
            res.allOps /= batchSize;
            res.measuredOps *= opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult((long)res.allOps, (long)res.measuredOps);
            results.add(new SampleTimeResult(ResultRole.PRIMARY, "baselineDouble", buffer, benchmarkParams.getTimeUnit()));

abs_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.abs(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

acosh_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.acosh(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

add_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_twocomplexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.add(l_twocomplexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_twocomplexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_twocomplexnumbers1_G.readyTrial) {
                            l_twocomplexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_twocomplexnumbers1_G, 0);
                    }
                } else {
                    long l_twocomplexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_twocomplexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_twocomplexnumbers1_G_backoff);
                        l_twocomplexnumbers1_G_backoff = Math.max(1024, l_twocomplexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_twocomplexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

asin_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.asin(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

atan_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.atan(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

baselineCopy_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.baselineCopy(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

conj_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.conj(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

cosh_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.cosh(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

divide_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_twocomplexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.divide(l_twocomplexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_twocomplexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_twocomplexnumbers1_G.readyTrial) {
                            l_twocomplexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_twocomplexnumbers1_G, 0);
                    }
                } else {
                    long l_twocomplexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_TwoComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_twocomplexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_twocomplexnumbers1_G_backoff);
                        l_twocomplexnumbers1_G_backoff = Math.max(1024, l_twocomplexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_twocomplexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

imag_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.imag(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

isInfinite_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.isInfinite(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

log10_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.log10(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

multiplyReal_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexandrealnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.multiplyReal(l_complexandrealnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

negate_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.negate(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

powReal_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexandrealnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.powReal(l_complexandrealnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

proj_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.proj(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

sin_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.sin(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

sqrtNorm_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.sqrtNorm(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

subtractReal_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexandrealnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.subtractReal(l_complexandrealnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

tan_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_complexnumbers1_G, l_complexperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_complexperformance0_G.tan(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

baselineIdentity_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_numbers1_G, l_sincosperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sincosperformance0_G.baselineIdentity(l_numbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

fastMathSin_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_numbers1_G, l_sincosperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sincosperformance0_G.fastMathSin(l_numbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

mathSin_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_numbers1_G, l_sincosperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sincosperformance0_G.mathSin(l_numbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

rangeMathSin_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_uniformnumbers1_G, l_sincosperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sincosperformance0_G.rangeMathSin(l_uniformnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_uniformnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_uniformnumbers1_G.readyTrial) {
                            l_uniformnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.set(l_uniformnumbers1_G, 0);
                    }
                } else {
                    long l_uniformnumbers1_G_backoff = 1;
                    while (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.get(l_uniformnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_uniformnumbers1_G_backoff);
                        l_uniformnumbers1_G_backoff = Math.max(1024, l_uniformnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_uniformnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

enormModExt_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.enormModExt(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

enormMod_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.enormMod(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

exact_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.exact(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

extLinearSinglePass_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.extLinearSinglePass(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

extLinear_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_euclideannormalgorithmperformance0_G.extLinear(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

directEuclideanArray_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_normperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_normperformance0_G.directEuclideanArray(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

euclidean3d_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput1_G, l_normperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_normperformance0_G.euclidean3d(l_vectorarrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

hypot_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_vectorarrayinput2d1_G, l_normperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_normperformance0_G.hypot(l_vectorarrayinput2d1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput2d1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput2d1_G.readyTrial) {
                            l_vectorarrayinput2d1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput2d1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput2d1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput2d1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput2d1_G_backoff);
                        l_vectorarrayinput2d1_G_backoff = Math.max(1024, l_vectorarrayinput2d1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput2d1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

baselineSingle_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_arrayinput1_G, l_sumperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sumperformance0_G.baselineSingle(l_arrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

sum_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_arrayinput1_G, l_sumperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_sumperformance0_G.sum(l_arrayinput1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

erf_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_erfdata1_G, l_erfperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_erfperformance0_G.erf(l_erfdata1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ErfPerformance_ErfData_jmhType.tearTrialMutexUpdater.compareAndSet(l_erfdata1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_erfdata1_G.readyTrial) {
                            l_erfdata1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ErfPerformance_ErfData_jmhType.tearTrialMutexUpdater.set(l_erfdata1_G, 0);
                    }
                } else {
                    long l_erfdata1_G_backoff = 1;
                    while (ErfPerformance_ErfData_jmhType.tearTrialMutexUpdater.get(l_erfdata1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_erfdata1_G_backoff);
                        l_erfdata1_G_backoff = Math.max(1024, l_erfdata1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_erfdata1_G = null;
                }
                synchronized(this.getClass()) {
                    f_erfperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

inverseErf_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_inverseerfdata1_G, l_erfperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_erfperformance0_G.inverseErf(l_inverseerfdata1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ErfPerformance_InverseErfData_jmhType.tearTrialMutexUpdater.compareAndSet(l_inverseerfdata1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_inverseerfdata1_G.readyTrial) {
                            l_inverseerfdata1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ErfPerformance_InverseErfData_jmhType.tearTrialMutexUpdater.set(l_inverseerfdata1_G, 0);
                    }
                } else {
                    long l_inverseerfdata1_G_backoff = 1;
                    while (ErfPerformance_InverseErfData_jmhType.tearTrialMutexUpdater.get(l_inverseerfdata1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_inverseerfdata1_G_backoff);
                        l_inverseerfdata1_G_backoff = Math.max(1024, l_inverseerfdata1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_inverseerfdata1_G = null;
                }
                synchronized(this.getClass()) {
                    f_erfperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

evaluate_thrpt_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, l_basedata1_G, l_gammacontinuedfractionperformance0_G);
            notifyControl.stopMeasurement = true;
            control.announceWarmdownReady();
            try {
                while (control.warmdownShouldWait) {
                    l_gammacontinuedfractionperformance0_G.evaluate(l_basedata1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (GammaContinuedFractionPerformance_BaseData_jmhType.tearTrialMutexUpdater.compareAndSet(l_basedata1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_basedata1_G.readyTrial) {
                            l_basedata1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        GammaContinuedFractionPerformance_BaseData_jmhType.tearTrialMutexUpdater.set(l_basedata1_G, 0);
                    }
                } else {
                    long l_basedata1_G_backoff = 1;
                    while (GammaContinuedFractionPerformance_BaseData_jmhType.tearTrialMutexUpdater.get(l_basedata1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_basedata1_G_backoff);
                        l_basedata1_G_backoff = Math.max(1024, l_basedata1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_basedata1_G = null;
                }
                synchronized(this.getClass()) {
                    f_gammacontinuedfractionperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;

addReal_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_complexandrealnumbers1_G, l_complexperformance0_G);
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexandrealnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexandrealnumbers1_G.readyTrial) {
                            l_complexandrealnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.set(l_complexandrealnumbers1_G, 0);
                    }
                } else {
                    long l_complexandrealnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexAndRealNumbers_jmhType.tearTrialMutexUpdater.get(l_complexandrealnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexandrealnumbers1_G_backoff);
                        l_complexandrealnumbers1_G_backoff = Math.max(1024, l_complexandrealnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexandrealnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
            long totalOps = opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
            results.add(new SingleShotResult(ResultRole.PRIMARY, "addReal", res.getTime(), totalOps, benchmarkParams.getTimeUnit()));

baselineIdentity_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_numbers1_G, l_sincosperformance0_G);
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_numbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_numbers1_G.readyTrial) {
                            l_numbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.set(l_numbers1_G, 0);
                    }
                } else {
                    long l_numbers1_G_backoff = 1;
                    while (SinCosPerformance_Numbers_jmhType.tearTrialMutexUpdater.get(l_numbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_numbers1_G_backoff);
                        l_numbers1_G_backoff = Math.max(1024, l_numbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_numbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
            long totalOps = opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
            results.add(new SingleShotResult(ResultRole.PRIMARY, "baselineIdentity", res.getTime(), totalOps, benchmarkParams.getTimeUnit()));

rangeFastMathSin_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_uniformnumbers1_G, l_sincosperformance0_G);
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_uniformnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_uniformnumbers1_G.readyTrial) {
                            l_uniformnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.set(l_uniformnumbers1_G, 0);
                    }
                } else {
                    long l_uniformnumbers1_G_backoff = 1;
                    while (SinCosPerformance_UniformNumbers_jmhType.tearTrialMutexUpdater.get(l_uniformnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_uniformnumbers1_G_backoff);
                        l_uniformnumbers1_G_backoff = Math.max(1024, l_uniformnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_uniformnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sincosperformance0_G = null;
                }
            }
            int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
            long totalOps = opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
            results.add(new SingleShotResult(ResultRole.PRIMARY, "rangeFastMathSin", res.getTime(), totalOps, benchmarkParams.getTimeUnit()));

direct_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_vectorarrayinput1_G, l_euclideannormalgorithmperformance0_G);
            control.preTearDown();

            if (control.isLastIteration()) {
                if (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (EuclideanNormAlgorithmPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_euclideannormalgorithmperformance0_G = null;
                }
            }
            int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
            long totalOps = opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
            results.add(new SingleShotResult(ResultRole.PRIMARY, "direct", res.getTime(), totalOps, benchmarkParams.getTimeUnit()));

baseline_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_vectorarrayinput1_G, l_normperformance0_G);
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput1_G.readyTrial) {
                            l_vectorarrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput1_G_backoff);
                        l_vectorarrayinput1_G_backoff = Math.max(1024, l_vectorarrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
            long totalOps = opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
            results.add(new SingleShotResult(ResultRole.PRIMARY, "baseline", res.getTime(), totalOps, benchmarkParams.getTimeUnit()));

euclidean2d_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_vectorarrayinput2d1_G, l_normperformance0_G);
            control.preTearDown();

            if (control.isLastIteration()) {
                if (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.compareAndSet(l_vectorarrayinput2d1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_vectorarrayinput2d1_G.readyTrial) {
                            l_vectorarrayinput2d1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.set(l_vectorarrayinput2d1_G, 0);
                    }
                } else {
                    long l_vectorarrayinput2d1_G_backoff = 1;
                    while (NormPerformance_VectorArrayInput2D_jmhType.tearTrialMutexUpdater.get(l_vectorarrayinput2d1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_vectorarrayinput2d1_G_backoff);
                        l_vectorarrayinput2d1_G_backoff = Math.max(1024, l_vectorarrayinput2d1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_vectorarrayinput2d1_G = null;
                }
                synchronized(this.getClass()) {
                    f_normperformance0_G = null;
                }
            }
            int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
            long totalOps = opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
            results.add(new SingleShotResult(ResultRole.PRIMARY, "euclidean2d", res.getTime(), totalOps, benchmarkParams.getTimeUnit()));

baselineDouble_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_arrayinput1_G, l_sumperformance0_G);
            control.preTearDown();

            if (control.isLastIteration()) {
                if (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.compareAndSet(l_arrayinput1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_arrayinput1_G.readyTrial) {
                            l_arrayinput1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.set(l_arrayinput1_G, 0);
                    }
                } else {
                    long l_arrayinput1_G_backoff = 1;
                    while (SumPerformance_ArrayInput_jmhType.tearTrialMutexUpdater.get(l_arrayinput1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_arrayinput1_G_backoff);
                        l_arrayinput1_G_backoff = Math.max(1024, l_arrayinput1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_arrayinput1_G = null;
                }
                synchronized(this.getClass()) {
                    f_sumperformance0_G = null;
                }
            }
            int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
            long totalOps = opsPerInv;
            BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
            results.add(new SingleShotResult(ResultRole.PRIMARY, "baselineDouble", res.getTime(), totalOps, benchmarkParams.getTimeUnit()));

l_complexperformance0_G.absMathHypot(l_complexnumbers1_G, blackhole);
                    res.allOps++;
                }
            } catch (Throwable e) {
                if (!(e instanceof InterruptedException)) throw e;
            }
            control.preTearDown();

            if (control.isLastIteration()) {
                if (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.compareAndSet(l_complexnumbers1_G, 0, 1)) {
                    try {
                        if (control.isFailing) throw new FailureAssistException();
                        if (l_complexnumbers1_G.readyTrial) {
                            l_complexnumbers1_G.readyTrial = false;
                        }
                    } catch (Throwable t) {
                        control.isFailing = true;
                        throw t;
                    } finally {
                        ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.set(l_complexnumbers1_G, 0);
                    }
                } else {
                    long l_complexnumbers1_G_backoff = 1;
                    while (ComplexPerformance_ComplexNumbers_jmhType.tearTrialMutexUpdater.get(l_complexnumbers1_G) == 1) {
                        TimeUnit.MILLISECONDS.sleep(l_complexnumbers1_G_backoff);
                        l_complexnumbers1_G_backoff = Math.max(1024, l_complexnumbers1_G_backoff * 2);
                        if (control.isFailing) throw new FailureAssistException();
                        if (Thread.interrupted()) throw new InterruptedException();
                    }
                }
                synchronized(this.getClass()) {
                    f_complexnumbers1_G = null;
                }
                synchronized(this.getClass()) {
                    f_complexperformance0_G = null;
                }
            }
            res.allOps += res.measuredOps;