diff --git a/system/jcstress/Generate.java b/system/jcstress/Generate.java
new file mode 100644
index 0000000000..7cfbd4580a
--- /dev/null
+++ b/system/jcstress/Generate.java
@@ -0,0 +1,977 @@
+import org.w3c.dom.Document;
+import org.xml.sax.ErrorHandler;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+import javax.xml.XMLConstants;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.stream.StreamSource;
+import javax.xml.validation.Schema;
+import javax.xml.validation.SchemaFactory;
+import javax.xml.validation.Validator;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+public class Generate {
+//Jcstress is printing output every 1000-15000ms . Considering runtime in hours the log can be pretty huge
+//In terminal, that is ok, but in jenkins, it is producing MB and MB of moreover useless logs 
+//There is undocumented jcstress.console.printIntervalMs whcih can set up this interval
+
+    // longest generated classes have 2131 tests
+    private static final int LIMIT = parseLimit();
+    private static final int MAX_NATURAL_ITERATIONS = parseMaxNaturalIterations();
+
+    private static final boolean SMALL_GROUPS = parseSmallGroups();
+
+    //those namespaces will not be merged together. This is literal eaquls comparison
+    private static final String[] NOT_MERGE_ABLE_GROUPS = new String[]{
+            "org",
+            "org.openjdk",
+            "org.openjdk.jcstress",
+            "org.openjdk.jcstress.tests",
+    };
+
+    private static final boolean SPLIT_BIG_BASES = parseSplitBigBases();
+
+    private static final String[] NOT_SPLIT_ABLE_GROUPS = parseSplitImsplittable();
+
+    private static final int DEFAULT_CORES = 2;
+    private static final String DEFAULT_TIMEBUDGET = "1h";
+
+    private static final String TEMPLATE = """
+            <test>
+            	<testCaseName>-TARGET-</testCaseName>
+            	<!-- -COMMENT-  -->
+                -DISABLED-
+                   <command>
+                     if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-CORES-" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\\
+                     if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-TB-" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\\
+                     if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-PRINT_INTERVAL_MS-" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\\
+                     $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)-JARFILE-$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "-REGEX-"; \\
+                     $(TEST_STATUS)
+                   </command>
+            	<levels>
+            		<level>dev</level>
+            	</levels>
+            	<groups>
+            		<group>system</group>
+            	</groups>
+            </test>""";
+    private static final String HEADER = """
+            <?xml version='1.0' encoding='UTF-8'?>
+            <!--
+            # Licensed under the Apache License, Version 2.0 (the "License");
+            # you may not use this file except in compliance with the License.
+            # You may obtain a copy of the License at
+            #
+            #      https://www.apache.org/licenses/LICENSE-2.0
+            #
+            # Unless required by applicable law or agreed to in writing, software
+            # distributed under the License is distributed on an "AS IS" BASIS,
+            # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+            # See the License for the specific language governing permissions and
+            # limitations under the License.
+            -->
+            <playlist xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../TKG/playlist.xsd">""";
+    private static final String FOOTER = "</playlist>";
+    private static URLClassLoader jarFileClasses;
+    private static String jvm;
+    private static File jarFile;
+
+
+    public static void main(String... args) throws Exception {
+        if (getOutputStyle().equals(OutputType.VALIDATE)){
+            String xml = readPlaylistArg(args);
+            validate(xml);
+            return;
+        }
+        String jar = readArg(args);
+        setAndPrintSetup();
+        setUsedJvm();
+        List<GroupWithCases> tests = listTestsClassesWithCasesFromJcStressJar(jvm, jar);
+        System.err.println("total tests files: " + tests.size());
+        print(tests);
+        List<GroupWithCases> groups = tests;
+        groups = mergeSmallGroupsToNaturalOnes(groups);
+        if (SMALL_GROUPS) {
+            groups = mergeSmallRemainingTestsToArtificialOnes(groups);
+        }
+        Collections.sort(groups);
+        System.err.println("Checksum:");
+        checksum(groups, tests, false, true, true);
+        System.err.println("Passed!");
+        sortByCount(groups);
+        print(groups);
+        if (OutputType.STATS == getOutputStyle()) {
+            for (GroupWithCases group : groups) {
+                System.out.println(group.toStringNoRegex());
+            }
+        } else if (OutputType.REGEXES == getOutputStyle()) {
+            for (GroupWithCases group : groups) {
+                System.out.println(group.regex);
+            }
+        } else if (OutputType.DO == getOutputStyle() || OutputType.TEST == getOutputStyle()) {
+            testTimesByRunningJcstress(groups);
+        } else {
+            printPlaylist(jarFile.getName(), groups);
+        }
+
+
+    }
+
+    private static List<GroupWithCases> mergeSmallRemainingTestsToArtificialOnes(List<GroupWithCases> groups) {
+        int x = 0;
+        while (true) {
+            x++;
+            List<GroupWithCases> bigCandidate = mergeSmallGroups(x, groups);
+            if (bigCandidate.size() == groups.size()) {
+                break;
+            }
+            groups = bigCandidate;
+            System.err.println("Small Group count " + x + " : " + groups.size());
+            print(groups);
+        }
+        return groups;
+    }
+
+    private static List<GroupWithCases> mergeSmallGroupsToNaturalOnes(List<GroupWithCases> groups) throws Exception {
+        int i = 0;
+        final Map<String, Integer> splitGroupsCounters = new HashMap<>();
+        while (true) {
+            i++;
+            if (i > MAX_NATURAL_ITERATIONS) {
+                break;
+            }
+            List<GroupWithCases> bigCandidate = groupTests(groups, splitGroupsCounters);
+            if (bigCandidate.size() == groups.size()) {
+                break;
+            }
+            groups = bigCandidate;
+            System.err.println("Natural groups round " + i + " : " + groups.size());
+            print(groups);
+        }
+        return groups;
+    }
+
+    private static void setUsedJvm() {
+        jvm = getUsedJvm();
+    }
+
+    private static String getUsedJvm() {
+        ProcessHandle processHandle = ProcessHandle.current();
+        return processHandle.info().command().orElse("java");
+    }
+
+    private static void setAndPrintSetup() {
+        System.err.println("Loading " + jarFile.getAbsolutePath());
+        System.err.println("Limit is " + LIMIT + "; no group with more then " + LIMIT + " of tests should be merged to bigger ones. Exclude list is of length of " + NOT_MERGE_ABLE_GROUPS.length);
+        if (SMALL_GROUPS) {
+            System.err.println("Small groups will be created.");
+        } else {
+            System.err.println("Small groups will not be created. Intentional?");
+        }
+        if (SPLIT_BIG_BASES) {
+            System.err.println("Huge groups will be split to more subsets. Exclude list is of length of " + NOT_SPLIT_ABLE_GROUPS.length);
+        } else {
+            System.err.println("Huge groups will NOT be split to more subsets. Intentional?");
+        }
+        System.err.println("Max count of natural grouping iterations is " + MAX_NATURAL_ITERATIONS);
+        if (parseUseFQN()) {
+            System.err.println("FQNs will be used in selectors");
+        } else {
+            System.err.println("Only N from FQN will be used. This saves space, but risks duplicate matches");
+        }
+        if (getCoresForPlaylist() == DEFAULT_CORES) {
+            System.err.println("Cores limit stays on default (" + DEFAULT_CORES + "). 0 is all.");
+        } else {
+            System.err.println("Cores for final playlist are " + getCoresForPlaylist() + ". Intentional? 0 is All.");
+        }
+        if (getTimeBudget() == DEFAULT_TIMEBUDGET) {
+            System.err.println("Time budget is default " + getTimeBudget() + ". Intentional? 0 is unlimited");
+        } else {
+            System.err.println("Time budget is " + getTimeBudget() + ". Intentional? 0 is unlimited");
+        }
+        System.err.println("PRINT_INTERVAL_MS is set as " + getOutputDelay() + " (milliseconds)");
+        if (getOutputStyle() == OutputType.GENERATE) {
+            System.err.println("Output will print playlist");
+        } else {
+            System.err.println("Output is set " + getOutputStyle());
+        }
+    }
+
+    private static String readArg(String[] args) throws MalformedURLException {
+        String jar = "../../../ci-jenkins-pipelines/tools/code-tools/jcstress/jcstress-tests-all-20240222.jar";
+        if (args.length > 0) {
+            jar = args[0];
+        }
+        jarFile = new File(jar);
+        if (!jarFile.exists()) {
+            throw new RuntimeException(jar + " does not exists");
+        }
+        URL[] cp = {jarFile.toURI().toURL()};
+        jarFileClasses = new URLClassLoader(cp);
+        return jar;
+    }
+
+    private static String readPlaylistArg(String[] args) throws MalformedURLException {
+        String jar = "playlist.xml";
+        if (args.length > 0) {
+            jar = args[0];
+        }
+        jarFile = new File(jar);
+        if (!jarFile.exists()) {
+            throw new RuntimeException(jar + " does not exists");
+        }
+        return jar;
+    }
+
+    private static TestDetails getJcstressTests(String clazz) throws Exception {
+        Class cl = jarFileClasses.loadClass(clazz);
+        int arbiters = getMethodsAnnotatedWith(cl, new String[]{"Arbiter"}).size();
+        int actors = getMethodsAnnotatedWith(cl, new String[]{"Actor"}).size();
+        return new ActorArbiter(actors, arbiters);
+    }
+
+    public static List<Method> getMethodsAnnotatedWith(final Class<?> type, final String[] annotationTypeNames) {
+        final List<Method> methods = new ArrayList<Method>();
+        Class<?> klass = type;
+        while (klass != Object.class) {
+            for (final Method method : klass.getDeclaredMethods()) {
+                if (isAnnotationPresent(method, annotationTypeNames)) {
+                    methods.add(method);
+                }
+            }
+            klass = klass.getSuperclass();
+        }
+        return methods;
+    }
+
+    private static boolean isAnnotationPresent(Method method, String[] annotationTypeNames) {
+        for (Annotation annotation : method.getAnnotations()) {
+            for (String annotationTypeName : annotationTypeNames) {
+                if (annotation.annotationType().getSimpleName().equals(annotationTypeName)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private static void printPlaylist(String jarName, List<GroupWithCases> groups) {
+        String timeBudgetString = "";
+        if (!getTimeBudget().equals("0")) {
+            timeBudgetString = "-tb " + getTimeBudget();
+        }
+        int cores = getCoresForPlaylist();
+        String coresString = "";
+        if (cores > 0) {
+            coresString = "-c " + cores;
+        }
+        System.out.println(HEADER);
+        System.out.println(TEMPLATE
+                .replace("-DISABLED-", "" +
+                        "                   <disables>\n" +
+                        "                     <disable>\n" +
+                        "                       <comment>even main target is now for manual usage only, as it runs very long</comment>\n" +
+                        "                     </disable>\n" +
+                        "                   </disables>")
+                .replace("-COMMENT-", "The running all. Due to time it needs, it is disabled by default.")
+                .replace("-JARFILE-", jarName)
+                .replace("-CORES-", coresString)
+                .replace("-PRINT_INTERVAL_MS-", getOutputDelay())
+                .replace("-TB-", timeBudgetString)
+                .replace("-TARGET-", "jcstress.all")
+                .replace("-REGEX-", ".*"));
+        int q = 0;
+        for (GroupWithCases group : groups) {
+            q++;
+            System.out.println(TEMPLATE
+                    .replace("-DISABLED-", "" +
+                            "                   <disables>\n" +
+                            "                     <disable>\n" +
+                            "                       <comment>all secondary targets are for manual usage now</comment>\n" +
+                            "                     </disable>\n" +
+                            "                   </disables>")
+                    .replace("-COMMENT-", q + "/" + groups.size() + " " + group.toStringNoRegex())
+                    .replace("-JARFILE-", jarName)
+                    .replace("-CORES-", coresString)
+                    .replace("-PRINT_INTERVAL_MS-", getOutputDelay())
+                    .replace("-TB-", timeBudgetString)
+                    .replace("-TARGET-", group.toTarget())
+                    .replace("-REGEX-", group.toSelector()));
+        }
+        System.out.println(FOOTER);
+    }
+
+    private static void testTimesByRunningJcstress(List<GroupWithCases> groups) throws IOException, InterruptedException {
+        final List<GroupWithCases> results = new ArrayList<>();
+        //It may happen we will kill it in runtime... good to print at least something
+        Runtime.getRuntime().addShutdownHook(new Thread() {
+            @Override
+            public void run() {
+                calculateStats(results, groups);
+            }
+        });
+        System.err.println("Starting measuring individual targets on " + getCoresForPlaylist() + " core(s) with" + jvm);
+        int counter = 0;
+        for (GroupWithCases group : groups) {
+            counter++;
+            Date start = new Date();
+            System.err.println(counter + "/" + groups.size() + " " + start + " starting " + group.toStringNoRegex());
+            List<String> args = getBasicJcstressCommand(jvm);
+            args.add("-t");
+            args.add(group.toSelector());
+            ProcessBuilder ps = new ProcessBuilder(args.toArray(new String[0]));
+            for (String cmd : ps.command()) {
+                System.err.print(cmd + " ");
+            }
+            System.err.println();
+            ps.redirectErrorStream(true);
+            Process pr = ps.start();
+            BufferedReader in = new BufferedReader(new InputStreamReader(pr.getInputStream()));
+            String line;
+            long fakeTime = -1;
+            while ((line = in.readLine()) != null) {
+                System.err.println(line);
+                if (OutputType.TEST == getOutputStyle()) {
+                    if (line.contains("Initial completion estimate:")) {
+                        line = line.replaceAll(".*Initial completion estimate: ", "").replaceAll(" left;.*", "");
+                        pr.destroy();
+                        System.err.println("Terminated for " + line);
+                        if (line.contains("d+")) {
+                            String[] daysHours = line.split("d\\+");
+                            fakeTime = hhmmss(daysHours[1]) + (Integer.parseInt(daysHours[0]) * 24 * 60 * 60);
+                        } else {
+                            fakeTime = hhmmss(line);
+                        }
+                        break;
+                    }
+                }
+            }
+            pr.waitFor();
+            in.close();
+            Date finished = new Date();
+            long deltaSeconds = (finished.getTime() - start.getTime()) / 1000l;
+            if (fakeTime > -1) {
+                deltaSeconds = fakeTime;
+            }
+            results.add(new GroupWithCases(group.name, group.regex, new Time((int) deltaSeconds), group.tests.getMainOne()));
+            String would = "";
+            if (OutputType.TEST == getOutputStyle()) {
+                would = " would ";
+            }
+            System.err.println(finished + would + " finished " + group.name + " in " + (deltaSeconds / 60) + " minutes");
+        }
+    }
+
+    private static String secondsToDays(long seconds) {
+        long days = (int) TimeUnit.SECONDS.toDays(seconds);
+        long hours = TimeUnit.SECONDS.toHours(seconds) - (days * 24);
+        long minutes = TimeUnit.SECONDS.toMinutes(seconds) - (TimeUnit.SECONDS.toHours(seconds) * 60);
+        long secondsLeft = TimeUnit.SECONDS.toSeconds(seconds) - (TimeUnit.SECONDS.toMinutes(seconds) * 60);
+        return days + "d+" + wrap((int) hours, 2) + ":" + wrap((int) minutes, 2) + ":" + wrap((int) secondsLeft, 2);
+    }
+
+
+    private static int getCoresForPlaylist() {
+        return getCores(DEFAULT_CORES);
+    }
+
+    private static int getCores(int def) {
+        return Integer.parseInt(System.getenv("CORES") == null || System.getenv("CORES") == "" ? "" + def : System.getenv("CORES"));
+    }
+    private static String getOutputDelay() {
+        return System.getenv("PRINT_INTERVAL_MS") == null ? "-Djcstress.console.printIntervalMs=3600000" : "-Djcstress.console.printIntervalMs=" + System.getenv("PRINT_INTERVAL_MS");
+    }
+
+    /**
+     * @return time with unit. Eg 100s or 30m
+     */
+    private static String getTimeBudget() {
+        return System.getenv("TIME_BUDGET") == null ? DEFAULT_TIMEBUDGET : System.getenv("TIME_BUDGET");
+    }
+
+    private static OutputType getOutputStyle() {
+        String output = System.getenv("OUTPUT");
+        if ("do".equals(output)) {
+            return OutputType.DO;
+        } else if ("test".equals(output)) {
+            return OutputType.TEST;
+        } else if ("stats".equals(output)) {
+            return OutputType.STATS;
+        } else if ("regexes".equals(output)) {
+            return OutputType.REGEXES;
+        } else if ("generate".equals(output)) {
+            return OutputType.GENERATE;
+        } else if ("validate".equals(output)) {
+            return OutputType.VALIDATE;
+        } else {
+            return OutputType.GENERATE;
+        }
+    }
+
+    private static long hhmmss(String line) {
+        String[] hms = line.split(":");
+        return (Integer.parseInt(hms[0]) * 60 * 60) + (Integer.parseInt(hms[1]) * 60) + (Integer.parseInt(hms[2]));
+    }
+
+    private static void checksum(List<GroupWithCases> groups, List<GroupWithCases> tests, boolean passes, boolean warning, boolean errors) {
+        final List<GroupWithCases> toBeMatched = new ArrayList<>(tests);
+        final List<GroupWithCases> matched = new ArrayList<>(tests.size());
+
+        int issues = 0;
+        for (GroupWithCases group : groups) {
+            int counter = 0;
+            for (GroupWithCases test : tests) {
+                if (test.name.matches(".*(" + group.regex + ")")) {
+                    counter++;
+                    matched.add(test);
+                    toBeMatched.remove(test);
+                }
+            }
+            if (counter == group.classes) {
+                if (passes) {
+                    title1(group);
+                    System.err.println("OK " + counter);
+                }
+            } else if (counter < group.classes) {
+                if (warning) {
+                    title1(group);
+                    System.err.println("warning " + counter);
+                }
+                issues++;
+            } else {
+                if (errors) {
+                    title1(group);
+                    System.err.println("ERROR " + counter);
+                }
+                issues++;
+            }
+        }
+        if (issues == 0) {
+            if (matched.size() != tests.size()) {
+                for (GroupWithCases test : toBeMatched) {
+                    System.err.println("Never matched: " + test);
+                }
+                throw new RuntimeException("Some tests were not matched! Expected " + tests.size() + " got " + matched.size());
+            }
+            if (!toBeMatched.isEmpty()) {
+                for (GroupWithCases test : toBeMatched) {
+                    System.err.println("Never matched: " + test);
+                }
+                throw new RuntimeException("Some tests were lost! Expected 0 got " + toBeMatched.size());
+            }
+        } else {
+            throw new RuntimeException("Some (" + issues + ") targets run more then they should. Try enhance blacklist, commit and rerun");
+        }
+    }
+
+    private static void title1(GroupWithCases group) {
+        System.err.println("target " + group.toTarget() + " expects " + group.classes + " hits for -t " + group.regex + "; got:");
+    }
+
+    private static List<GroupWithCases> mergeSmallGroups(int id, List<GroupWithCases> groups1) {
+        GroupWithCases candidate = new GroupWithCases("small.groups." + id, "", new ActorArbiter(0, 0), 0);
+        List<GroupWithCases> groups2 = new ArrayList<>(150);
+        for (GroupWithCases origGroup : groups1) {
+            if (origGroup.tests.getMainOne() > LIMIT) {
+                groups2.add(origGroup);
+            } else {
+                if (candidate.tests.getMainOne() <= LIMIT) {
+                    candidate.add(origGroup.tests, origGroup.classes);
+                    candidate.appendRegex(origGroup.regex);
+                } else {
+                    groups2.add(origGroup);
+                }
+            }
+        }
+        if (candidate.classes > 0) {
+            groups2.add(candidate);
+        }
+        return groups2;
+    }
+
+    private static void print(List<GroupWithCases> groups1) {
+        if (isVerbose()) {
+            sortByCount(groups1);
+            for (GroupWithCases group : groups1) {
+                System.err.println(group);
+            }
+        }
+    }
+
+    private static void sortByCount(List<GroupWithCases> groups1) {
+        Collections.sort(groups1, new Comparator<GroupWithCases>() {
+            @Override
+            public int compare(GroupWithCases t1, GroupWithCases t2) {
+                return t1.tests.getMainOne() - t2.tests.getMainOne();
+            }
+        });
+    }
+
+    private static List<GroupWithCases> groupTests(List<GroupWithCases> tests, Map<String, Integer> splitGroupsCounters) throws Exception {
+        List<String> exludes = Arrays.stream(NOT_MERGE_ABLE_GROUPS).toList();
+        List<GroupWithCases> groups1 = new ArrayList<>(300);
+        for (GroupWithCases test : tests) {
+            int subtestIndex = test.name.lastIndexOf('.');
+            String groupName;
+            if (subtestIndex < 0) {
+                groupName = test.name;
+            } else {
+                groupName = test.name.substring(0, subtestIndex);
+            }
+            if (SPLIT_BIG_BASES && !isExcludedFromSplitting(groupName)) {
+                int currentId = splitGroupsCounters.getOrDefault(groupName, 1);
+                String groupNameWithId = groupName + "-" + wrap(currentId, 3);
+                GroupWithCases candidate;
+                if (exludes.contains(groupName) || test.tests.getMainOne() > LIMIT) {
+                    candidate = test;
+                } else {
+                    candidate = new GroupWithCases(groupNameWithId, test.regex, false);
+                    candidate.add(test.tests, test.classes);
+                }
+                int i = groups1.indexOf(candidate);
+                if (i >= 0) {
+                    GroupWithCases foundGroup = groups1.get(i);
+                    foundGroup.add(candidate.tests, candidate.classes);
+                    foundGroup.appendRegex(candidate.regex);
+                    if (foundGroup.tests.getMainOne() > LIMIT) {
+                        splitGroupsCounters.put(groupName, currentId + 1);
+                    }
+                } else {
+                    groups1.add(candidate);
+                }
+            } else {
+                GroupWithCases candidate;
+                if (exludes.contains(groupName) || test.tests.getMainOne() > LIMIT) {
+                    candidate = test;
+                } else {
+                    candidate = new GroupWithCases(groupName, test.regex, false);
+                    candidate.add(test.tests, test.classes);
+                }
+                int i = groups1.indexOf(candidate);
+                if (i >= 0) {
+                    GroupWithCases foundGroup = groups1.get(i);
+                    foundGroup.add(candidate.tests, candidate.classes);
+                    foundGroup.appendRegex(candidate.regex);
+                } else {
+                    groups1.add(candidate);
+                }
+            }
+        }
+        return groups1;
+    }
+
+    private static boolean isExcludedFromSplitting(String groupName) {
+        for (String r : NOT_SPLIT_ABLE_GROUPS) {
+            if (groupName.matches(r)) {
+                if (isVerbose()) {
+                    System.err.println(groupName + " ecluded by " + r);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean isVerbose() {
+        return "true".equals(System.getenv("VERBOSE"));
+    }
+
+    public static String wrap(int number, int length) {
+        String s = "" + number;
+        return wrap(s, length);
+    }
+
+    public static String wrap(String number, int length) {
+        String s = number;
+        while (s.length() < length) {
+            s = "0" + s;
+        }
+        return s;
+    }
+
+    private static List<GroupWithCases> listTestsClassesWithCasesFromJcStressJar(String jvm, String jar) throws Exception {
+        List<String> args = getBasicJcstressCommand(jvm);
+        args.add("-l");
+        ProcessBuilder ps = new ProcessBuilder(args.toArray(new String[0]));
+        long totalTest = 0;
+        ps.redirectErrorStream(true);
+        Process pr = ps.start();
+        BufferedReader in = new BufferedReader(new InputStreamReader(pr.getInputStream()));
+        List<GroupWithCases> tests = new ArrayList<>(500);
+        String line;
+        while ((line = in.readLine()) != null) {
+            if (line.startsWith("org.")) {
+                if (!line.contains(".samples.") && line.contains(".tests.")) {
+                    GroupWithCases clazz = new GroupWithCases(line, true);
+                    totalTest += clazz.tests.getMainOne();
+                    tests.add(clazz);
+                }
+            }
+        }
+        pr.waitFor();
+        in.close();
+        System.err.println("Total test cases: " + totalTest);
+        return tests;
+    }
+
+    private static List<String> getBasicJcstressCommand(String jvm) {
+        List<String> args = new ArrayList<>();
+        args.add(jvm);
+        args.add("-jar");
+        args.add(jarFile.getAbsolutePath());
+        //warning, many tests needs two or more cores!
+        int cores = getCoresForPlaylist();
+        if (cores > 0) {
+            args.add("-c");
+            args.add(cores + "");
+        }
+        if (!getTimeBudget().equals("0")) {
+            args.add("-tb");
+            args.add(getTimeBudget());
+        }
+        return args;
+    }
+
+    private static int parseLimit() {
+        return Integer.parseInt(System.getenv("LIMIT") == null ? "100" : System.getenv("LIMIT"));
+    }
+
+    private static boolean parseSmallGroups() {
+        if ("true".equals(System.getenv("SMALL_GROUPS"))) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    private static int parseMaxNaturalIterations() {
+        //for very long, default was Integer.MAX_VALUE
+        return Integer.parseInt(System.getenv("MAX_NATURAL_ITERATIONS") == null ? "3" : System.getenv("MAX_NATURAL_ITERATIONS"));
+    }
+
+
+    private static boolean parseUseFQN() {
+        if ("true".equals(System.getenv("FQN"))) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    private static String[] parseSplitImsplittable() {
+        if ("false".equals(System.getenv("SPLIT_ALL"))) {
+            // those groups are  known to contain a lot of tests,
+            // however are known to run very quickly, so we do not want them to be split
+            return new String[]{
+                    /*both thsoe grops are highly affecte dby CORES. 2 cors, 2 hours. 4cores, 45days! */
+                    /*So based on agreement with cores, those shoudl be excluded/includes...*/
+                    "org.openjdk.jcstress.tests.seqcst.sync.*",
+                    "org.openjdk.jcstress.tests.seqcst.volatiles.*",
+            };
+        } else {
+            return new String[0];
+        }
+    }
+
+    private static boolean parseSplitBigBases() {
+        if ("true".equals(System.getenv("SPLIT_BIG_BASES"))) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+
+    public static void calculateStats(List<GroupWithCases> results, List<GroupWithCases> resultsExpected) {
+        System.out.println("Exiting");
+        System.out.println("Results gathered: " + results.size() + " of expected " + resultsExpected.size() + "; 100% time of longest group, n% time of ideal group from really run results");
+        if (results.isEmpty()) {
+            return;
+        }
+        //first total time
+        long totalTime = 0;
+        for (GroupWithCases time : results) {
+            totalTime += (long) (time.tests.getMainOne());
+        }
+        long avgTimeExpected = totalTime / results.size();
+        if (!getTimeBudget().equals("0")) {
+            System.out.println(" - The calculations from real run are provided. They are based on meassured times and real results (not expected results)");
+            System.out.println(" - You had -tb " + getTimeBudget() + " set, so yours expected avg tim is " + getTimeBudget() + " and not the measured real values bellow");
+            System.out.println(" - Your workload should have run " + resultsExpected.size() + " * " + getTimeBudget() + " but run " + secondsToDays(totalTime) + " and was finished " + results.size() + " from " + resultsExpected.size());
+            System.out.println(" - See https://bugs.openjdk.org/browse/CODETOOLS-7903750");
+        }
+        //now details
+        sortByCount(results);
+        Collections.reverse(results);
+        int longest = results.get(0).tests.getMainOne();
+        long maxTime = Long.MIN_VALUE;
+        long minTime = Long.MAX_VALUE;
+        int forLongestPercentAvg = 0;
+        int forAvgPercentAvg = 0;
+        for (GroupWithCases time : results) {
+            if (time.tests.getMainOne() > maxTime) {
+                maxTime = time.tests.getMainOne();
+            }
+            if (time.tests.getMainOne() < minTime) {
+                minTime = time.tests.getMainOne();
+            }
+            int percentLongest = ((time.tests.getMainOne() * 100) / longest);
+            forLongestPercentAvg += percentLongest;
+            long percentAvg = ((time.tests.getMainOne() * 100) / avgTimeExpected);
+            //differences by both directions from 100%
+            String sign = "";
+            if (percentAvg == 100) {
+                percentAvg = 100 - percentAvg;
+                sign = "";
+            } else if (percentAvg > 100) {
+                percentAvg = percentAvg - 100;
+                sign = "+";
+            } else {
+                percentAvg = 100 - percentAvg;
+                sign = "-";
+            }
+            ;
+            forAvgPercentAvg += percentAvg;
+            String prefix = "";
+            if (time.tests.getMainOne() < 30) {
+                prefix = "Error? ";
+            }
+            System.out.println(prefix + time.name + " with " + time.classes + "tests took " + time.tests + " [" + secondsToDays(time.tests.getMainOne()) + "] (" + percentLongest + "%)(" + sign + percentAvg + "%)");
+        }
+        System.out.println("Total time: " + totalTime / 60l + " minutes [" + secondsToDays(totalTime) + "]");
+        System.out.println("Ideal avg time: " + avgTimeExpected / 60l + " minutes [" + secondsToDays(avgTimeExpected) + "] (100%)");
+        System.out.println("Max seen  time: " + maxTime / 60l + " minutes [" + secondsToDays(maxTime) + "] (" + ((maxTime * 100) / avgTimeExpected) + "%)");
+        System.out.println("Min seen  time: " + minTime / 60l + " minutes [" + secondsToDays(minTime) + "] (" + ((minTime * 100) / avgTimeExpected) + "%)");
+        System.out.println("Avg differecne from longest: " + forLongestPercentAvg / results.size() + "%");
+        System.out.println("Avg differecne from ideal: " + (100 - (forAvgPercentAvg / results.size())) + "%");
+    }
+
+    public static void validate(String xml) throws Exception {
+        System.err.println("Checking: " + xml);
+        wellFormed(xml);
+        validByXsd(xml);
+    }
+
+    public static void wellFormed(String xml) throws ParserConfigurationException, SAXException, IOException {
+        System.err.println("Well formed?");
+        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+        factory.setValidating(false);
+        factory.setNamespaceAware(true);
+        DocumentBuilder builder = factory.newDocumentBuilder();
+        Document document = builder.parse(new InputSource(xml));
+        System.err.println("Well formed!");
+    }
+
+    public static void validByXsd(String xml) throws ParserConfigurationException, SAXException, IOException {
+        String url = "https://raw.githubusercontent.com/adoptium/TKG/master/resources/playlist.xsd";
+        System.err.println("Valid by " + url + " ?");
+        SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
+        Schema schema = factory.newSchema(new URL(url));
+        Validator validator = schema.newValidator();
+        validator.validate(new StreamSource(new File(xml)));
+        System.err.println("Valid!");
+    }
+
+    private enum OutputType {
+        GENERATE, DO, TEST, STATS, REGEXES, VALIDATE
+    }
+
+    private interface TestDetails {
+        int getMainOne();
+
+        int getAll();
+
+        void add(Object testDetails);
+
+    }
+
+    private static class GroupWithCases implements Comparable<GroupWithCases> {
+        final String name;
+        String regex;
+        TestDetails tests;
+        int classes;
+
+        public GroupWithCases(String name, boolean clazz) throws Exception {
+            this(name, name, clazz);
+        }
+
+        public GroupWithCases(String name, String regex, boolean clazz) throws Exception {
+            this.name = name;
+            if (clazz) {
+                if (parseUseFQN()) {
+                    this.regex = regex;
+                } else {
+                    this.regex = regex.replace("org.openjdk.jcstress.", "");
+                }
+            } else {
+                this.regex = regex;
+            }
+            if (clazz) {
+                String innerGroup = name;
+                while (true) {
+                    try {
+                        tests = getJcstressTests(innerGroup);
+                        classes = 1;
+                        break;
+                    } catch (ClassNotFoundException ex) {
+                        innerGroup = replaceLast(innerGroup, "\\.", "$");
+                        if (!innerGroup.contains(".")) {
+                            throw ex;
+                        }
+                    }
+                }
+            } else {
+                tests = new ActorArbiter(0, 0);
+                classes = 0;
+            }
+        }
+
+        public GroupWithCases(String name, String regex, TestDetails testDetails, int classes) {
+            this.name = name;
+            this.regex = regex;
+            this.tests = testDetails;
+            this.classes = classes;
+        }
+
+        private String replaceLast(String string, String what, String by) {
+            String reverse = new StringBuffer(string).reverse().toString();
+            Matcher matcher = Pattern.compile(what).matcher(reverse);
+            reverse = matcher.replaceFirst(matcher.quoteReplacement(by));
+            string = new StringBuffer(reverse).reverse().toString();
+            return string;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            GroupWithCases that = (GroupWithCases) o;
+            return Objects.equals(name, that.name);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(name);
+        }
+
+        @Override
+        public int compareTo(GroupWithCases that) {
+            return this.name.compareTo(that.name);
+        }
+
+        public void add(TestDetails toAdd, int classes) {
+            this.tests.add(toAdd);
+            this.classes += classes;
+        }
+
+        @Override
+        public String toString() {
+            return toStringNoRegex() + " via (" + regex + ")";
+        }
+
+        public String toStringNoRegex() {
+            return name + ": classes " + classes + "/tests " + tests;
+        }
+
+        public String toTarget() {
+            return name.replace("org.openjdk.jcstress.tests.", "jcstress.");
+        }
+
+        public String title() {
+            return "target " + toTarget() + " will run " + tests + " tests in -t " + regex;
+        }
+
+        public void appendRegex(String regex) {
+            if (this.regex.isEmpty()) {
+                this.regex = regex;
+            } else {
+                this.regex = this.regex + "|" + regex;
+            }
+        }
+
+        public String toSelector() {
+            //currently no op, but there were attempts to repalce | operator by different ones or to use more interesting wildchars
+            return regex;
+        }
+    }
+
+    private static class ActorArbiter implements TestDetails {
+
+        int actors;
+        int arbiters;
+
+        public ActorArbiter(int actors, int arbiters) {
+            this.actors = actors;
+            this.arbiters = arbiters;
+        }
+
+        public int getMainOne() {
+            return actors + arbiters;
+        }
+
+        public int getAll() {
+            return actors + arbiters;
+        }
+
+        public void add(Object testDetails) {
+            this.actors += ((ActorArbiter) testDetails).actors;
+            this.arbiters += ((ActorArbiter) testDetails).arbiters;
+        }
+
+        @Override
+        public String toString() {
+            return getMainOne() + "(ac/ar:" + actors + "/" + arbiters + ")";
+        }
+    }
+
+    private static class Time implements TestDetails {
+        final int time;
+
+        public Time(int time) {
+            this.time = time;
+        }
+
+        public int getMainOne() {
+            return time;
+        }
+
+        public int getAll() {
+            return time;
+        }
+
+        public void add(Object testDetails) {
+            throw new IllegalArgumentException("Time can not be added");
+        }
+
+        @Override
+        public String toString() {
+            return getMainOne() + "s";
+        }
+    }
+
+}
diff --git a/system/jcstress/README.md b/system/jcstress/README.md
new file mode 100644
index 0000000000..975f269917
--- /dev/null
+++ b/system/jcstress/README.md
@@ -0,0 +1,321 @@
+# AQA jcstress runner
+
+This playlist runs by default all jcstress tests in minimal `time budget`.  Currently  it is just `-tb 1h` which is trying to squeeze all 11543 tests from jcstress-20240222 to 1hour.  That is not going to work, but the suite should try to squeeze itself to absolute minimum. Another switch which can minimize runtime is `-c` - number of cores to use, although it was not recommended by upstream, ve default to 2.
+
+Other targets are generated subgroups to run targeted groups of tests in case that the affected area could do cause an issue.  Dont forget you have to prefix such target by `disabled...` keyword. All those targets are run with all cores and no forced time budget. 
+
+Both main tests and generated subgroups can take `$JC_TIME_BUDGET` variable to set the time budget and `$JC_CORES` to set number of cores. Set it to empty or 0 to override default 2.  In addition standard `$APPLICATION_OPTIONS` is honoured.
+
+# AQA jcstress playlist generator and tester
+The generator is slightly over-engineered but do its job quite well. It takes only one argument - the file to jcstress.jar. The name of file maters - it is used in the command.
+
+**It is necessary that default usage of the generator always prints the playlist.xml as it shuold be**
+
+Adjust the defaults in `Generate.java` if you change them. `javac Generate.java` and `java Generate.java <pathToJcstressJar> > playlist.xml` should do the job.
+
+Except the generation the class can also print final standalone statistics or regexes for future research. It can also calculate estimated time of all groups by forking and killing jcstress jar (of course this feature is useless with `-tb`). It can also run all the jcstress groups, and calculate precise times. Current implementation looks like:
+<details>
+<summary>Setup</summary>
+<pre>
+Limit is 100; no group with more then 100 of tests should be merged to bigger ones. Exclude list is of length of 4
+Small groups will not be created. Intentional?
+Huge groups will NOT be split to more subsets. Intentional?
+Max count of natural grouping iterations is 3
+Only N from FQN will be used. This saves space, but risks duplicate matches
+Cores limit for final playlist is not used
+Time budget is not used. Intentional?
+Output is set TEST
+Total test cases: 11543
+total tests files: 4374
+Natural groups round 1 : 251
+Natural groups round 2 : 112
+Natural groups round 3 : 82
+</pre>
+</details>
+<details>
+<summary>Times</summary>
+<pre>
+Results gathered: 82 of expected 82; 100% time of longest group, n% time of ideal group from really run results
+org.openjdk.jcstress.tests.seqcst.volatiles with 2131tests took 3928320s [45d+11:12:00] (100%)(+3494%)
+org.openjdk.jcstress.tests.seqcst.sync with 2131tests took 3928320s [45d+11:12:00] (100%)(+3494%)
+org.openjdk.jcstress.tests.volatiles with 39tests took 71135s [0d+19:45:35] (1%)(-35%)
+org.openjdk.jcstress.tests.locks.stamped.StampedLockPairwiseTests with 450tests took 64799s [0d+17:59:59] (1%)(-41%)
+org.openjdk.jcstress.tests.causality with 43tests took 42911s [0d+11:55:11] (1%)(-61%)
+org.openjdk.jcstress.tests.fences.varHandles with 196tests took 28223s [0d+07:50:23] (0%)(-75%)
+org.openjdk.jcstress.tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater with 192tests took 27648s [0d+07:40:48] (0%)(-75%)
+org.openjdk.jcstress.tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater with 192tests took 27647s [0d+07:40:47] (0%)(-75%)
+org.openjdk.jcstress.tests.memeffects.basic.atomic.AtomicLong with 192tests took 27647s [0d+07:40:47] (0%)(-75%)
+org.openjdk.jcstress.tests.memeffects.basic.atomic.AtomicInteger with 192tests took 27647s [0d+07:40:47] (0%)(-75%)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.heap.little with 168tests took 24192s [0d+06:43:12] (0%)(-78%)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteArray.big with 168tests took 24192s [0d+06:43:12] (0%)(-78%)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.heap.big with 168tests took 24191s [0d+06:43:11] (0%)(-78%)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.direct.little with 168tests took 24191s [0d+06:43:11] (0%)(-78%)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.direct.big with 168tests took 24191s [0d+06:43:11] (0%)(-78%)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteArray.little with 168tests took 24191s [0d+06:43:11] (0%)(-78%)
+org.openjdk.jcstress.tests.locks.mutex with 160tests took 23039s [0d+06:23:59] (0%)(-79%)
+org.openjdk.jcstress.tests.memeffects.basic with 156tests took 22463s [0d+06:14:23] (0%)(-80%)
+org.openjdk.jcstress.tests.oota with 13tests took 19440s [0d+05:24:00] (0%)(-83%)
+org.openjdk.jcstress.tests.acqrel.varHandles.fields.volatiles with 126tests took 18144s [0d+05:02:24] (0%)(-84%)
+org.openjdk.jcstress.tests.acqrel.varHandles.arrays.volatiles with 126tests took 18144s [0d+05:02:24] (0%)(-84%)
+org.openjdk.jcstress.tests.acqrel.varHandles.arrays.acqrel with 126tests took 18144s [0d+05:02:24] (0%)(-84%)
+org.openjdk.jcstress.tests.acqrel.fields.volatiles with 126tests took 18144s [0d+05:02:24] (0%)(-84%)
+org.openjdk.jcstress.tests.acqrel.fields.sync with 126tests took 18144s [0d+05:02:24] (0%)(-84%)
+org.openjdk.jcstress.tests.atomicity with 126tests took 18143s [0d+05:02:23] (0%)(-84%)
+org.openjdk.jcstress.tests.acqrel.varHandles.fields.acqrel with 126tests took 18143s [0d+05:02:23] (0%)(-84%)
+org.openjdk.jcstress.tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests with 111tests took 15840s [0d+04:24:00] (0%)(-86%)
+org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests with 111tests took 15840s [0d+04:24:00] (0%)(-86%)
+org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerArrayPairwiseTests with 111tests took 15840s [0d+04:24:00] (0%)(-86%)
+org.openjdk.jcstress.tests.atomics.longs.AtomicLongPairwiseTests with 111tests took 15839s [0d+04:23:59] (0%)(-86%)
+org.openjdk.jcstress.tests.atomics.longs.AtomicLongArrayPairwiseTests with 111tests took 15839s [0d+04:23:59] (0%)(-86%)
+org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests with 111tests took 15839s [0d+04:23:59] (0%)(-86%)
+org.openjdk.jcstress.tests.atomicity.varHandles.byteBuffer.heap with 162tests took 15552s [0d+04:19:12] (0%)(-86%)
+org.openjdk.jcstress.tests.atomicity.varHandles.byteBuffer.direct with 162tests took 15552s [0d+04:19:12] (0%)(-86%)
+org.openjdk.jcstress.tests.atomicity.varHandles.byteArray with 162tests took 15551s [0d+04:19:11] (0%)(-86%)
+org.openjdk.jcstress.tests.coherence.varHandles with 108tests took 15551s [0d+04:19:11] (0%)(-86%)
+org.openjdk.jcstress.tests.accessAtomic.varHandles with 108tests took 15551s [0d+04:19:11] (0%)(-86%)
+org.openjdk.jcstress.tests.atomicity.varHandles.arrays with 141tests took 13536s [0d+03:45:36] (0%)(-88%)
+org.openjdk.jcstress.tests.atomicity.varHandles.fields with 141tests took 13535s [0d+03:45:35] (0%)(-88%)
+org.openjdk.jcstress.tests.atomicity.varHandles.fields.WeakCASContendStrongTest with 108tests took 10368s [0d+02:52:48] (0%)(-91%)
+org.openjdk.jcstress.tests.atomicity.varHandles.arrays.WeakCASTest with 108tests took 10368s [0d+02:52:48] (0%)(-91%)
+org.openjdk.jcstress.tests.accessAtomic.varHandles.byteBuffer.heap with 72tests took 10368s [0d+02:52:48] (0%)(-91%)
+org.openjdk.jcstress.tests.accessAtomic.varHandles.byteArray with 72tests took 10368s [0d+02:52:48] (0%)(-91%)
+org.openjdk.jcstress.tests.atomicity.varHandles.fields.WeakCASTest with 108tests took 10367s [0d+02:52:47] (0%)(-91%)
+org.openjdk.jcstress.tests.atomicity.varHandles.arrays.WeakCASContendStrongTest with 108tests took 10367s [0d+02:52:47] (0%)(-91%)
+org.openjdk.jcstress.tests.coherence.varHandles.byteBuffer.heap with 72tests took 10367s [0d+02:52:47] (0%)(-91%)
+org.openjdk.jcstress.tests.coherence.varHandles.byteBuffer.direct with 72tests took 10367s [0d+02:52:47] (0%)(-91%)
+org.openjdk.jcstress.tests.coherence.varHandles.byteArray with 72tests took 10367s [0d+02:52:47] (0%)(-91%)
+org.openjdk.jcstress.tests.accessAtomic.varHandles.byteBuffer.direct with 72tests took 10367s [0d+02:52:47] (0%)(-91%)
+org.openjdk.jcstress.tests.countdownlatch with 24tests took 9791s [0d+02:43:11] (0%)(-92%)
+org.openjdk.jcstress.tests.tearing with 87tests took 8352s [0d+02:19:12] (0%)(-93%)
+org.openjdk.jcstress.tests.copy.manual.arrays with 56tests took 8064s [0d+02:14:24] (0%)(-93%)
+org.openjdk.jcstress.tests.copy.arraycopy.arrays with 56tests took 8064s [0d+02:14:24] (0%)(-93%)
+org.openjdk.jcstress.tests.copy.copyof.arrays with 56tests took 8063s [0d+02:14:23] (0%)(-93%)
+org.openjdk.jcstress.tests.copy.clone.arrays with 56tests took 8063s [0d+02:14:23] (0%)(-93%)
+org.openjdk.jcstress.tests.coherence with 54tests took 7776s [0d+02:09:36] (0%)(-93%)
+org.openjdk.jcstress.tests.accessAtomic with 54tests took 7775s [0d+02:09:35] (0%)(-93%)
+org.openjdk.jcstress.tests.init with 52tests took 7488s [0d+02:04:48] (0%)(-94%)
+org.openjdk.jcstress.tests.initClass.arrays with 36tests took 5184s [0d+01:26:24] (0%)(-96%)
+org.openjdk.jcstress.tests.init.arrays with 36tests took 5184s [0d+01:26:24] (0%)(-96%)
+org.openjdk.jcstress.tests.defaultValues with 36tests took 5184s [0d+01:26:24] (0%)(-96%)
+org.openjdk.jcstress.tests.tearing.arrays with 54tests took 5183s [0d+01:26:23] (0%)(-96%)
+org.openjdk.jcstress.tests.accessAtomic.fields with 54tests took 5183s [0d+01:26:23] (0%)(-96%)
+org.openjdk.jcstress.tests.locks with 36tests took 5183s [0d+01:26:23] (0%)(-96%)
+org.openjdk.jcstress.tests.initLen.arrays with 36tests took 5183s [0d+01:26:23] (0%)(-96%)
+org.openjdk.jcstress.tests.initClass with 36tests took 5183s [0d+01:26:23] (0%)(-96%)
+org.openjdk.jcstress.tests.defaultValues.arrays with 36tests took 5183s [0d+01:26:23] (0%)(-96%)
+org.openjdk.jcstress.tests.singletons with 28tests took 4032s [0d+01:07:12] (0%)(-97%)
+org.openjdk.jcstress.tests.copy.clone with 28tests took 4032s [0d+01:07:12] (0%)(-97%)
+org.openjdk.jcstress.tests.copy.manual with 28tests took 4031s [0d+01:07:11] (0%)(-97%)
+org.openjdk.jcstress.tests.atomics with 28tests took 3743s [0d+01:02:23] (0%)(-97%)
+org.openjdk.jcstress.tests.fences with 16tests took 2303s [0d+00:38:23] (0%)(-98%)
+org.openjdk.jcstress.tests.strings with 17tests took 2016s [0d+00:33:36] (0%)(-99%)
+org.openjdk.jcstress.tests.unsafe with 10tests took 1439s [0d+00:23:59] (0%)(-99%)
+org.openjdk.jcstress.tests.varhandles with 6tests took 864s [0d+00:14:24] (0%)(-100%)
+org.openjdk.jcstress.tests.executors with 6tests took 576s [0d+00:09:36] (0%)(-100%)
+org.openjdk.jcstress.tests.future with 5tests took 575s [0d+00:09:35] (0%)(-100%)
+org.openjdk.jcstress.tests.interrupt with 15tests took 540s [0d+00:09:00] (0%)(-100%)
+org.openjdk.jcstress.tests.sample with 3tests took 288s [0d+00:04:48] (0%)(-100%)
+org.openjdk.jcstress.tests.collections with 3tests took 287s [0d+00:04:47] (0%)(-100%)
+org.openjdk.jcstress.tests.threadlocal with 2tests took 287s [0d+00:04:47] (0%)(-100%)
+org.openjdk.jcstress.tests.mxbeans with 2tests took 287s [0d+00:04:47] (0%)(-100%)
+Total time: 149338 minutes [103d+16:58:38]
+Ideal avg time: 1821 minutes [1d+06:21:12] (100%)
+Max seen  time: 65472 minutes [45d+11:12:00] (3594%)
+Min seen  time: 4 minutes [0d+00:04:47] (0%)
+Avg differecne from longest: 2%
+Avg differecne from ideal: -70%
+</pre>
+</details>
+<details>
+<summary>Number of tests</summary>
+<pre>
+org.openjdk.jcstress.tests.mxbeans: classes 1/tests 2(ac/ar:2/0)
+org.openjdk.jcstress.tests.threadlocal: classes 1/tests 2(ac/ar:2/0)
+org.openjdk.jcstress.tests.collections: classes 1/tests 3(ac/ar:2/1)
+org.openjdk.jcstress.tests.sample: classes 1/tests 3(ac/ar:2/1)
+org.openjdk.jcstress.tests.future: classes 2/tests 5(ac/ar:4/1)
+org.openjdk.jcstress.tests.executors: classes 2/tests 6(ac/ar:4/2)
+org.openjdk.jcstress.tests.varhandles: classes 3/tests 6(ac/ar:6/0)
+org.openjdk.jcstress.tests.unsafe: classes 5/tests 10(ac/ar:10/0)
+org.openjdk.jcstress.tests.oota: classes 5/tests 13(ac/ar:13/0)
+org.openjdk.jcstress.tests.interrupt: classes 15/tests 15(ac/ar:15/0)
+org.openjdk.jcstress.tests.fences: classes 8/tests 16(ac/ar:16/0)
+org.openjdk.jcstress.tests.strings: classes 7/tests 17(ac/ar:14/3)
+org.openjdk.jcstress.tests.countdownlatch: classes 10/tests 24(ac/ar:24/0)
+org.openjdk.jcstress.tests.atomics: classes 13/tests 28(ac/ar:26/2)
+org.openjdk.jcstress.tests.copy.clone: classes 14/tests 28(ac/ar:28/0)
+org.openjdk.jcstress.tests.copy.manual: classes 14/tests 28(ac/ar:28/0)
+org.openjdk.jcstress.tests.singletons: classes 14/tests 28(ac/ar:28/0)
+org.openjdk.jcstress.tests.defaultValues: classes 18/tests 36(ac/ar:36/0)
+org.openjdk.jcstress.tests.defaultValues.arrays: classes 18/tests 36(ac/ar:36/0)
+org.openjdk.jcstress.tests.init.arrays: classes 18/tests 36(ac/ar:36/0)
+org.openjdk.jcstress.tests.initClass: classes 18/tests 36(ac/ar:36/0)
+org.openjdk.jcstress.tests.initClass.arrays: classes 18/tests 36(ac/ar:36/0)
+org.openjdk.jcstress.tests.initLen.arrays: classes 18/tests 36(ac/ar:36/0)
+org.openjdk.jcstress.tests.locks: classes 18/tests 36(ac/ar:36/0)
+org.openjdk.jcstress.tests.volatiles: classes 15/tests 39(ac/ar:39/0)
+org.openjdk.jcstress.tests.causality: classes 18/tests 43(ac/ar:43/0)
+org.openjdk.jcstress.tests.init: classes 26/tests 52(ac/ar:52/0)
+org.openjdk.jcstress.tests.accessAtomic: classes 27/tests 54(ac/ar:54/0)
+org.openjdk.jcstress.tests.accessAtomic.fields: classes 18/tests 54(ac/ar:36/18)
+org.openjdk.jcstress.tests.coherence: classes 27/tests 54(ac/ar:54/0)
+org.openjdk.jcstress.tests.tearing.arrays: classes 18/tests 54(ac/ar:36/18)
+org.openjdk.jcstress.tests.copy.arraycopy.arrays: classes 28/tests 56(ac/ar:56/0)
+org.openjdk.jcstress.tests.copy.clone.arrays: classes 28/tests 56(ac/ar:56/0)
+org.openjdk.jcstress.tests.copy.copyof.arrays: classes 28/tests 56(ac/ar:56/0)
+org.openjdk.jcstress.tests.copy.manual.arrays: classes 28/tests 56(ac/ar:56/0)
+org.openjdk.jcstress.tests.accessAtomic.varHandles.byteArray: classes 36/tests 72(ac/ar:72/0)
+org.openjdk.jcstress.tests.accessAtomic.varHandles.byteBuffer.direct: classes 36/tests 72(ac/ar:72/0)
+org.openjdk.jcstress.tests.accessAtomic.varHandles.byteBuffer.heap: classes 36/tests 72(ac/ar:72/0)
+org.openjdk.jcstress.tests.coherence.varHandles.byteArray: classes 36/tests 72(ac/ar:72/0)
+org.openjdk.jcstress.tests.coherence.varHandles.byteBuffer.direct: classes 36/tests 72(ac/ar:72/0)
+org.openjdk.jcstress.tests.coherence.varHandles.byteBuffer.heap: classes 36/tests 72(ac/ar:72/0)
+org.openjdk.jcstress.tests.tearing: classes 29/tests 87(ac/ar:58/29)
+org.openjdk.jcstress.tests.accessAtomic.varHandles: classes 54/tests 108(ac/ar:108/0)
+org.openjdk.jcstress.tests.atomicity.varHandles.arrays.WeakCASContendStrongTest: classes 36/tests 108(ac/ar:72/36)
+org.openjdk.jcstress.tests.atomicity.varHandles.arrays.WeakCASTest: classes 36/tests 108(ac/ar:72/36)
+org.openjdk.jcstress.tests.atomicity.varHandles.fields.WeakCASContendStrongTest: classes 36/tests 108(ac/ar:72/36)
+org.openjdk.jcstress.tests.atomicity.varHandles.fields.WeakCASTest: classes 36/tests 108(ac/ar:72/36)
+org.openjdk.jcstress.tests.coherence.varHandles: classes 54/tests 108(ac/ar:108/0)
+org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerArrayPairwiseTests: classes 55/tests 111(ac/ar:110/1)
+org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests: classes 55/tests 111(ac/ar:110/1)
+org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests: classes 55/tests 111(ac/ar:110/1)
+org.openjdk.jcstress.tests.atomics.longs.AtomicLongArrayPairwiseTests: classes 55/tests 111(ac/ar:110/1)
+org.openjdk.jcstress.tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests: classes 55/tests 111(ac/ar:110/1)
+org.openjdk.jcstress.tests.atomics.longs.AtomicLongPairwiseTests: classes 55/tests 111(ac/ar:110/1)
+org.openjdk.jcstress.tests.acqrel.fields.sync: classes 63/tests 126(ac/ar:126/0)
+org.openjdk.jcstress.tests.acqrel.fields.volatiles: classes 63/tests 126(ac/ar:126/0)
+org.openjdk.jcstress.tests.acqrel.varHandles.arrays.acqrel: classes 63/tests 126(ac/ar:126/0)
+org.openjdk.jcstress.tests.acqrel.varHandles.arrays.volatiles: classes 63/tests 126(ac/ar:126/0)
+org.openjdk.jcstress.tests.acqrel.varHandles.fields.acqrel: classes 63/tests 126(ac/ar:126/0)
+org.openjdk.jcstress.tests.acqrel.varHandles.fields.volatiles: classes 63/tests 126(ac/ar:126/0)
+org.openjdk.jcstress.tests.atomicity: classes 63/tests 126(ac/ar:126/0)
+org.openjdk.jcstress.tests.atomicity.varHandles.arrays: classes 47/tests 141(ac/ar:94/47)
+org.openjdk.jcstress.tests.atomicity.varHandles.fields: classes 47/tests 141(ac/ar:94/47)
+org.openjdk.jcstress.tests.memeffects.basic: classes 78/tests 156(ac/ar:156/0)
+org.openjdk.jcstress.tests.locks.mutex: classes 80/tests 160(ac/ar:160/0)
+org.openjdk.jcstress.tests.atomicity.varHandles.byteArray: classes 54/tests 162(ac/ar:108/54)
+org.openjdk.jcstress.tests.atomicity.varHandles.byteBuffer.direct: classes 54/tests 162(ac/ar:108/54)
+org.openjdk.jcstress.tests.atomicity.varHandles.byteBuffer.heap: classes 54/tests 162(ac/ar:108/54)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteArray.big: classes 84/tests 168(ac/ar:168/0)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteArray.little: classes 84/tests 168(ac/ar:168/0)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.direct.big: classes 84/tests 168(ac/ar:168/0)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.direct.little: classes 84/tests 168(ac/ar:168/0)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.heap.big: classes 84/tests 168(ac/ar:168/0)
+org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.heap.little: classes 84/tests 168(ac/ar:168/0)
+org.openjdk.jcstress.tests.memeffects.basic.atomic.AtomicInteger: classes 96/tests 192(ac/ar:192/0)
+org.openjdk.jcstress.tests.memeffects.basic.atomic.AtomicLong: classes 96/tests 192(ac/ar:192/0)
+org.openjdk.jcstress.tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater: classes 96/tests 192(ac/ar:192/0)
+org.openjdk.jcstress.tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater: classes 96/tests 192(ac/ar:192/0)
+org.openjdk.jcstress.tests.fences.varHandles: classes 98/tests 196(ac/ar:196/0)
+org.openjdk.jcstress.tests.locks.stamped.StampedLockPairwiseTests: classes 225/tests 450(ac/ar:450/0)
+org.openjdk.jcstress.tests.seqcst.sync: classes 489/tests 2131(ac/ar:1642/489)
+org.openjdk.jcstress.tests.seqcst.volatiles: classes 489/tests 2131(ac/ar:1642/489)
+</pre>
+</details>
+
+*Each runtime generator is run, it first **verify**, that **all** tests will be **run**, and that **each** will be run exactly **once**.* Also, in `test` mode (and of course in `do` mode) it verifies, that each group can be launched. Because the `|` expressions may grow very long, and under some circumstances may flow out of shell's boundaries.
+
+## Control variables
+In order of importance and reasonability
+ * OUTPUT - one of  
+   * do - will run all groups as jcstress (takes ages!).  If interrupted, will print at least what was calculated up to that time
+   * test - will fork and kill `java jcstress.jar` and estimate time of all groups. If interrupted, will print at least what was calculated up to that time
+   * stats - will print amount of tests in each group
+   * regexes - will print just final regexes
+   * validate - will validate given (instead of jar) playlist.xml
+   * **generate - default, will print playlist.xml to stdout**
+ * LIMIT - number. **default is 100**. Every group smaller then LIMIT will be merged to bigger subset.
+ * SMALL_GROUPS - true/false. **default is false**. After natural grouping is done, all remaining groups smaller then LIMIT are merged to artificial groups
+ * SPLIT_BIG_BASES - true/false. **default is false**. Each natural  group group bigger then LIMIT is split once it reaches limit.
+ * MAX_NATURAL_ITERATIONS - number, usually 1-10, how many namespaces can be cut for natural grouping.
+ * CORES - number, **defaults to 2**. Set to 0 to use all cores (recomeded by upstream, but runing surprsingly long)
+ * TIME_BUDGET - string, **defaults to 1h**. set to anything you think your tests will fit. This is just best effort, not a strict cut. It is upstream bug. 0 i sunlimited.
+ * VERBOSE - set to true to see a lot of weird stuff
+ * FQN - set to true to use fully qualified names instead of shortened ones. This may casue soem targets to not fit to OS cmdline limit.
+ <details>
+<summary>eg:</summary>
+<pre>
+org.openjdk.jcstress.tests.atomicity.varHandles.arrays.WeakCASContendStrongTest
+org.openjdk.jcstress.tests.atomicity.varHandles.arrays.WeakCASTest
+org.openjdk.jcstress.tests.atomicity.varHandles.fields.WeakCASContendStrongTest
+org.openjdk.jcstress.tests.atomicity.varHandles.fields.WeakCASTest:
+
+Are not mixed, because MAX_NATURAL_ITERATIONS was 3. If it would be 4, one more level would be  cut (if LIMIT allows), to:
+org.openjdk.jcstress.tests.atomicity.varHandles.arrays
+org.openjdk.jcstress.tests.atomicity.varHandles.fields
+
+If it would be 5, and LIMIT would allow, it would cut one more: to
+org.openjdk.jcstress.tests.atomicity.varHandles
+</pre>
+</details>
+
+ * CORES - number, **null by default (thus all cores)**. Number of cores used to generate list and and run jcstress.
+ * TIME_BUDGET - time budget, **null by default (thus no limit)**. Applies only to generated groups. The default target `all` have hardcoded value
+ * FQN - **false by default**. If true, no prefix would be cut from tests in `|` expressions
+ * SPLIT_ALL - **true by default**, if false, some hardcoded groups, which are known to have a lot of tests, but run surprisingly quickly are excluded from splitting if `SPLIT_BIG_BASES` is true.
+ * VERBOSE - prints some debugging info. **false by default**. Enable byu setting to true.
+
+
+ It is obvious, that the `Generate.java` can create pretty balanced groups by number of tests, but it proved to be not exactly useful, as single jcsrtress tests do not have constant duration. The `-tb` is usually not honoured, it is common to exceed it by 200% but also by 20000% - https://bugs.openjdk.org/browse/CODETOOLS-7903750
+
+ ### Algorithm:
+  * the natural groups are finished first. They are created by grouping packages.
+    * this runs in iterations, and by default breaks when iteration merges nothing
+    * if `MAX_NATURAL_ITERATIONS` is enabled, then it stops merging after MAX_NATURAL_ITERATIONS of iterations.
+    * each group with less then `LIMIT` of members is merged to another with shares namespace
+    * if `SPLIT_BIG_BASES` is enabled, then each namespaces will be split so it do not exceed LIMIT.
+  * if `SMALL_GROUPS` are enabled then all leftovers smaller then LIMIT are merged to unnatural groups at the end.
+    * Again, once this artificial group reaches limit no more tests is added 
+
+Before this playlist was created, many experiments were run:
+<details>
+<pre>
+
+ 1 core : Total time: 9 minutes [0d+00:09:35]
+ 2 cores: Total time: 16458 minutes [11d+10:18:34]
+ 3 cores: Total time: 33695 minutes [23d+09:35:21]
+ 4 cores: Total time: 149339 minutes [103d+16:59:21]
+ 8 cores: Total time: 149339 minutes [103d+16:59:20] 
+
+ split_exl Limit 10 - 603 groups, from those  7 "small groups" (0.5hours each. %like longest/ideal %17%/? (6m-2.5h)
+ split_all Limit 10 - 603 groups, from those  7 "small groups" (0.5hours each. %like longest/ideal %68%/81 (26m-38m)
+ split_exl Limit 50 - 128 groups, from those  6 "small groups" (~2.5hhours each. %like longest/ideal %60/85% (45m-3.5h)
+ split_all Limit 50 - 206 groups, from those  7 "small groups" (~1.1 hours each. %like longest/ideal %37/27% (6s-3.5h)   
+   (there was an error (eg for rg.openjdk.jcstress.tests.seqcst.sync-028) 3 actors:   No scheduling is possible, these tests would not run. Which I need to investiagte and maybe fall back to simple more simple class counting, or run also the -l listing with -c (which seems most correct, as -l is indeed counting with -c)
+ the real min time would be some 1hour.
+ split_exl Limit 100 - 60 groups, from those  7 "small groups" (~4.5hours each. %like longest/ideal %63/79% (2.5h-7h)
+ split_all Limit 100 - 99 groups, from those  7 "small groups" (~2.5hours each . %like longest/ideal %38/21% (7s-7h)
+   (same error, so real min time would be again some 2.5 hours)
+ 
+  The estimated times are highly CORES sensitive. Some tests do not even run with CORES=1!
+  Some groups, eg org.openjdk.jcstress.tests.seqcst.sync and org.openjdk.jcstress.tests.seqcst.volatiles are highly affected by cores (2->2hours 4=>45days!)
+  other groups are slightly less affected by cores, but still are.
+  
+  This table was genrated with CORES=2 in TEST mode (thus with aprox 75% accuracy).
+  jcstress20240202  4400classes with 11500 tests.
+  Note, that `%like longest/ideal` is better closer to bigger/bigger.
+  all: 2 cores and org.openjdk.jcstress.tests.seqcst.sync and org.openjdk.jcstress.tests.seqcst.volatiles not split:
+  all: MAX_NATURAL_ITERATIONS=Integer.max_value SMALL_GROUPS=true SPLIT_BIG_BASES=true
+  Limit 5 - 1207 groups, from those  8 "small groups" (not tried... yet... to long...)
+  split_exl Limit 10 - 603 groups, from those  7 "small groups" (0.5hours each. %like longest/ideal %17%/? (6m-2.5h)
+  split_all Limit 10 - 603 groups, from those  7 "small groups" (0.5hours each. %like longest/ideal %68%/81? (26m-38mm)
+  Limit 50 - 128 groups, from those  6 "small groups" (~2.5hhours each. %like longest/ideal %60/85% (45m-3.5h)
+  Limit 100 - 60 groups, from those  7 "small groups" (~4.5hours each. %like longest/ideal %63/79% (2.5h-7h)
+  Limit 250 - 25 groups, from those  4 "small groups" (~11hours each. %like longest/ideal 63%/77% (2.5h-17h)
+  Limit 500 - 14 groups, from those  4 "small groups" (~20hours each. %like longest/ideal 59%/60% (1.5h-1d 9h)
+  Limit 1000 - 9 groups, from those  5 "small groups" (~1day 6hours each. %like longest/ideal 42%/41% (2.5h-3d)
+  Limit 2000 - 6 groups, from those  4 "small groups" (~2day each, %like longest/ideal 41%/9% (2.5h-4d)
+  Limit 5000 - 3 groups, from those  3 "small groups" (unknown, selector argument to long for one of groups)
+  Limit 50000 - 1 groups, from those 1 "small groups" (unknown, selector argument to long)
+  all tests in batch ~11.5 of day
+  The minimal 2.5 which is invalidating huge groups a bit, are  the two excluded gorg.openjdk.jcstress.tests.seqcst.sync and org.openjdk.jcstress.tests.seqcst.volatiles,
+ 
+  Note, that LIMIT is not strictly honored. It is jsut saying, that if there LIMIT of testes or more, it wil not be grouped.
+  So in worse scenario, LIMIT-1+LIMIT-1 will join to group of size of (2*LIMIT)-2, but it is very rare,
+  and in addition the time of one test is very far from being constant, so this deviation in size of grtoup (LIMIT+1, <2*LIMIT)-2> is minimal.
+  If small groups are enagetOutputSbled, and they should be, there wil nearly always be some leftover group with size <= LIMIT
+</pre>
+</details>
+
+So any regenerator, be warned, it seems it is impossible to group jcstress tests in really balanced way. In addition, it omitting any si a no go, all jcstress test are equally important.
diff --git a/system/jcstress/playlist.xml b/system/jcstress/playlist.xml
index 685223baa0..0a180e0055 100644
--- a/system/jcstress/playlist.xml
+++ b/system/jcstress/playlist.xml
@@ -12,1709 +12,1831 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 -->
-<playlist xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../TKG/resources/playlist.xsd">
-	<test>
-		<testCaseName>jcstress_BooleanFencedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t BooleanFencedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_IntFencedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t IntFencedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ByteFencedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ByteFencedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_FloatFencedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t FloatFencedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_LongFencedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t LongFencedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DoubleFencedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DoubleFencedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ShortFencedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ShortFencedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_CharFencedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t CharFencedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_SyncBarrier2Test</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t SyncBarrier2Test; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_SyncBarrier3Test</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t SyncBarrier3Test; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_SyncBarrier1Test</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t SyncBarrier1Test; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_SyncBarrier0Test</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t SyncBarrier0Test; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ReentrantRWLockMutexTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ReentrantRWLockMutexTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_SynchronizedMutexPoolTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t SynchronizedMutexPoolTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ReentrantLockMutexTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ReentrantLockMutexTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_SynchronizedMutexTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t SynchronizedMutexTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_StampedLockPairwiseTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t StampedLockPairwiseTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_StampedLockTransitionTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t StampedLockTransitionTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ThreadMXBeanAlloc</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ThreadMXBeanAlloc; \
-			$(TEST_STATUS)</command>
-		<disables>
-			<disable>
-				<comment>git_ibm/runtimes/backlog/issues/979</comment>
-				<impl>openj9</impl>
-				<version>8+</version>
-			</disable>
-		</disables>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnfencedReadTwiceTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnfencedReadTwiceTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_FencedDekkerTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t FencedDekkerTest; \
-			$(TEST_STATUS)</command>
-		<disables>
-			<disable>
-				<comment>https://github.com/eclipse-openj9/openj9/issues/16178 runtimes/backlog/979</comment>
-				<impl>openj9</impl>
-				<version>8+</version>
-			</disable>
-		</disables>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_FencedAcquireReleaseTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t FencedAcquireReleaseTest; \
-			$(TEST_STATUS)</command>
-		<disables>
-			<disable>
-				<comment>https://github.com/eclipse-openj9/openj9/issues/16178 runtimes/backlog/988</comment>
-				<impl>openj9</impl>
-				<version>8+</version>
-			</disable>
-		</disables>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnfencedDekkerTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnfencedDekkerTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_FencedReadTwiceTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t FencedReadTwiceTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnfencedAcquireReleaseTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnfencedAcquireReleaseTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnfencedPublicationTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnfencedPublicationTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_FencedPublicationTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t FencedPublicationTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnsafeLocalDCL</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnsafeLocalDCL; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnsafeDCL</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnsafeDCL; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_Holder</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t Holder; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_SynchronizedCL</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t SynchronizedCL; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_SafeDCL</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t SafeDCL; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_FinalWrapper</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t FinalWrapper; \
-			$(TEST_STATUS)</command>
-		<disables>
-			<disable>
-				<comment>https://github.com/eclipse-openj9/openj9/issues/16569</comment>
-				<impl>openj9</impl>
-				<platform>.*(aarch64_mac|ppc64_aix).*</platform>
-				<version>8+</version>
-			</disable>
-		</disables>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_SafeLocalDCL</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t SafeLocalDCL; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ScalarReplacedVolatileBarrierTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ScalarReplacedVolatileBarrierTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_PowerSCViolation</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t PowerSCViolation; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ReadTwiceOverVolatileReadTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ReadTwiceOverVolatileReadTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DoubleVolatileTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DoubleVolatileTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ObservedVolatileBarrierTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ObservedVolatileBarrierTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_VolatileIncrementAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t VolatileIncrementAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnobservedVolatileBarrierTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnobservedVolatileBarrierTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_VolatileIRIWTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t VolatileIRIWTest; \
-			$(TEST_STATUS)</command>
-		<disables>
-			<disable>
-				<comment>runtimes/backlog/988</comment>
-				<impl>openj9</impl>
-				<version>8+</version>
-			</disable>
-		</disables>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_LazySetTransitivityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t LazySetTransitivityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DekkerTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DekkerTest; \
-			$(TEST_STATUS)</command>
-		<disables>
-			<disable>
-				<comment>git_ibm/runtimes/backlog/issues/973 and 979</comment>
-				<impl>openj9</impl>
-				<version>8+</version>
-			</disable>
-		</disables>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_RelaxedIRIWTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t RelaxedIRIWTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_VolatileAcquireReleaseTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t VolatileAcquireReleaseTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ReadAfterReadTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ReadAfterReadTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ReadAfterVolatileReadTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ReadAfterVolatileReadTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_OpaqueIRIWTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t OpaqueIRIWTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_StringBufferTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t StringBufferTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_BigDecimalString</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t BigDecimalString; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_StringBuilderTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t StringBuilderTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_StringBufferAppendTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t StringBufferAppendTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_BigIntegerStringLen</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t BigIntegerStringLen; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_BigDecimalStringLen</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t BigDecimalStringLen; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_BigIntegerString</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t BigIntegerString; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ThreadLocalSharing</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ThreadLocalSharing; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ByteBufferIntAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ByteBufferIntAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DirectByteBufferIntAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DirectByteBufferIntAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnsafeIntAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnsafeIntAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_CharBufferAtomicityTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t CharBufferAtomicityTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DoubleBufferAtomicityTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DoubleBufferAtomicityTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ByteBufferAtomicityTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ByteBufferAtomicityTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_FloatBufferAtomicityTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t FloatBufferAtomicityTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_LongBufferAtomicityTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t LongBufferAtomicityTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ByteBufferViewsAtomicityTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ByteBufferViewsAtomicityTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ShortBufferAtomicityTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ShortBufferAtomicityTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DirectByteBufferAtomicityTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DirectByteBufferAtomicityTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_IntBufferAtomicityTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t IntBufferAtomicityTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DirectByteBufferViewsAtomicityTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DirectByteBufferViewsAtomicityTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_LongAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t LongAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_VolatileFloatAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t VolatileFloatAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_FloatAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t FloatAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ByteAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ByteAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_CharAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t CharAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_VolatileDoubleAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t VolatileDoubleAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DoubleAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DoubleAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_IntAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t IntAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ShortAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ShortAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_VolatileByteAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t VolatileByteAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_VolatileIntAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t VolatileIntAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_VolatileLongAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t VolatileLongAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_VolatileShortAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t VolatileShortAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_VolatileCharAtomicityTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t VolatileCharAtomicityTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_TimeUnitSleepTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t TimeUnitSleepTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_VolatileBusyLoopTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t VolatileBusyLoopTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_CurrentThreadIsInterruptedMethodTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t CurrentThreadIsInterruptedMethodTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_WeakReferenceTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t WeakReferenceTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ThreadInterruptedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ThreadInterruptedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_PlainBusyLoopTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t PlainBusyLoopTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ReentrantLockNonInterruptiblyTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ReentrantLockNonInterruptiblyTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_CurrentThreadIsInterruptedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t CurrentThreadIsInterruptedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ObjectWaitInfiniteTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ObjectWaitInfiniteTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ThreadInterruptedMethodTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ThreadInterruptedMethodTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ThreadSleepTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ThreadSleepTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnsafeBusyLoopTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnsafeBusyLoopTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_CurrentThreadIsInterruptedBreakTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t CurrentThreadIsInterruptedBreakTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ThreadInterruptedBreakTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ThreadInterruptedBreakTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ReentrantLockInterruptiblyTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ReentrantLockInterruptiblyTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ObjectWaitTimedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ObjectWaitTimedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicBooleanPairwiseTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicBooleanPairwiseTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicBooleanInitialValueTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicBooleanInitialValueTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicIntegerArrayPairwiseTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicIntegerArrayPairwiseTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicIntegerInitialValueTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicIntegerInitialValueTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicIntegerArrayInitialValueTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicIntegerArrayInitialValueTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicIntegerPairwiseTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicIntegerPairwiseTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicIntegerArrayInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicIntegerArrayInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicIntegerFieldUpdaterPairwiseTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicIntegerFieldUpdaterPairwiseTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicLongArrayInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicLongArrayInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicLongArrayInitialValueTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicLongArrayInitialValueTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicLongPairwiseTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicLongPairwiseTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicLongFieldUpdaterPairwiseTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicLongFieldUpdaterPairwiseTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicLongInitialValueTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicLongInitialValueTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_AtomicLongArrayPairwiseTests</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t AtomicLongArrayPairwiseTests; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ByteBufferInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ByteBufferInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DoubleBufferInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DoubleBufferInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_LongBufferInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t LongBufferInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_FloatBufferInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t FloatBufferInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_CharBufferInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t CharBufferInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_IntBufferInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t IntBufferInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DirectByteBufferInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DirectByteBufferInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ShortBufferInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ShortBufferInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ArrayInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ArrayInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnsafeIntTearingTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnsafeIntTearingTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnsafeArrayInterleaveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnsafeArrayInterleaveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ThreadPoolExecutorSizesTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ThreadPoolExecutorSizesTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ThreadPoolExecutorKeepAliveTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ThreadPoolExecutorKeepAliveTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnsafeAddLong1</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnsafeAddLong1; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnsafeReadTwiceOverVolatileReadTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnsafeReadTwiceOverVolatileReadTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnsafePutOrderedTwice</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnsafePutOrderedTwice; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnsafeAddLong42</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnsafeAddLong42; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnsafePublication</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnsafePublication; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_Sevcik_01_Redundant_WAR_Elimination</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t Sevcik_01_Redundant_WAR_Elimination; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_Sevcik_03_RoachMotel</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t Sevcik_03_RoachMotel; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_Sevcik_02_Redundant_RAR_Elimination</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t Sevcik_02_Redundant_RAR_Elimination; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_Sevcik_04_IrrelevantRead</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t Sevcik_04_IrrelevantRead; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_Sevcik_05_IllegalTransform</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t Sevcik_05_IllegalTransform; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_SampleTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t SampleTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_BoundedSingleTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t BoundedSingleTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnboundedSingleTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnboundedSingleTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_StringBoundedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t StringBoundedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_StringUnboundedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t StringUnboundedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_IntUnboundedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t IntUnboundedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_IntBoundedTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t IntBoundedTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_UnboundedDoubleTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t UnboundedDoubleTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_BoundedDoubleTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t BoundedDoubleTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_HashMapFailureTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t HashMapFailureTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DekkerRelaxation2Test</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DekkerRelaxation2Test; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_DekkerRelaxation1Test</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t DekkerRelaxation1Test; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_FutureTaskSetTest</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t FutureTaskSetTest; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-	<test>
-		<testCaseName>jcstress_ThreadNames</testCaseName>
-		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) -t ThreadNames; \
-			$(TEST_STATUS)</command>
-		<levels>
-			<level>dev</level>
-		</levels>
-		<groups>
-			<group>system</group>
-		</groups>
-	</test>
-</playlist>
\ No newline at end of file
+<playlist xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../TKG/playlist.xsd">
+<test>
+	<testCaseName>jcstress.all</testCaseName>
+	<!-- The running all. Due to time it needs, it is disabled by default.  -->
+                       <disables>
+                     <disable>
+                       <comment>even main target is now for manual usage only, as it runs very long</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t ".*"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.mxbeans</testCaseName>
+	<!-- 1/82 org.openjdk.jcstress.tests.mxbeans: classes 1/tests 2(ac/ar:2/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.mxbeans.ThreadMXBeanAlloc"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.threadlocal</testCaseName>
+	<!-- 2/82 org.openjdk.jcstress.tests.threadlocal: classes 1/tests 2(ac/ar:2/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.threadlocal.ThreadLocalSharing"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.collections</testCaseName>
+	<!-- 3/82 org.openjdk.jcstress.tests.collections: classes 1/tests 3(ac/ar:2/1)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.collections.HashMapFailureTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.sample</testCaseName>
+	<!-- 4/82 org.openjdk.jcstress.tests.sample: classes 1/tests 3(ac/ar:2/1)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.sample.SampleTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.future</testCaseName>
+	<!-- 5/82 org.openjdk.jcstress.tests.future: classes 2/tests 5(ac/ar:4/1)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.future.FutureTaskSetTest|tests.future.ThreadNames"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.executors</testCaseName>
+	<!-- 6/82 org.openjdk.jcstress.tests.executors: classes 2/tests 6(ac/ar:4/2)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.executors.ThreadPoolExecutorKeepAliveTest|tests.executors.ThreadPoolExecutorSizesTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.varhandles</testCaseName>
+	<!-- 7/82 org.openjdk.jcstress.tests.varhandles: classes 3/tests 6(ac/ar:6/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.varhandles.DekkerRelaxation1Test|tests.varhandles.DekkerRelaxation2Test|tests.varhandles.DekkerTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.unsafe</testCaseName>
+	<!-- 8/82 org.openjdk.jcstress.tests.unsafe: classes 5/tests 10(ac/ar:10/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.unsafe.UnsafeAddLong1|tests.unsafe.UnsafeAddLong42|tests.unsafe.UnsafePublication|tests.unsafe.UnsafePutOrderedTwice|tests.unsafe.UnsafeReadTwiceOverVolatileReadTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.oota</testCaseName>
+	<!-- 9/82 org.openjdk.jcstress.tests.oota: classes 5/tests 13(ac/ar:13/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.oota.Sevcik_01_Redundant_WAR_Elimination|tests.oota.Sevcik_02_Redundant_RAR_Elimination|tests.oota.Sevcik_03_RoachMotel|tests.oota.Sevcik_04_IrrelevantRead|tests.oota.Sevcik_05_IllegalTransform"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.interrupt</testCaseName>
+	<!-- 10/82 org.openjdk.jcstress.tests.interrupt: classes 15/tests 15(ac/ar:15/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.interrupt.CurrentThreadIsInterruptedBreakTest|tests.interrupt.CurrentThreadIsInterruptedMethodTest|tests.interrupt.CurrentThreadIsInterruptedTest|tests.interrupt.ObjectWaitInfiniteTest|tests.interrupt.ObjectWaitTimedTest|tests.interrupt.PlainBusyLoopTest|tests.interrupt.ReentrantLockInterruptiblyTest|tests.interrupt.ReentrantLockNonInterruptiblyTest|tests.interrupt.ThreadInterruptedBreakTest|tests.interrupt.ThreadInterruptedMethodTest|tests.interrupt.ThreadInterruptedTest|tests.interrupt.ThreadSleepTest|tests.interrupt.TimeUnitSleepTest|tests.interrupt.UnsafeBusyLoopTest|tests.interrupt.VolatileBusyLoopTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.fences</testCaseName>
+	<!-- 11/82 org.openjdk.jcstress.tests.fences: classes 8/tests 16(ac/ar:16/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.fences.FencedAcquireReleaseTest|tests.fences.FencedDekkerTest|tests.fences.FencedPublicationTest|tests.fences.FencedReadTwiceTest|tests.fences.UnfencedAcquireReleaseTest|tests.fences.UnfencedDekkerTest|tests.fences.UnfencedPublicationTest|tests.fences.UnfencedReadTwiceTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.strings</testCaseName>
+	<!-- 12/82 org.openjdk.jcstress.tests.strings: classes 7/tests 17(ac/ar:14/3)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.strings.BigDecimalString|tests.strings.BigDecimalStringLen|tests.strings.BigIntegerString|tests.strings.BigIntegerStringLen|tests.strings.StringBufferAppendTest|tests.strings.StringBufferTest|tests.strings.StringBuilderTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.countdownlatch</testCaseName>
+	<!-- 13/82 org.openjdk.jcstress.tests.countdownlatch: classes 10/tests 24(ac/ar:24/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.countdownlatch.effects.IntBoundedTest|tests.countdownlatch.effects.IntUnboundedTest|tests.countdownlatch.effects.StringBoundedTest|tests.countdownlatch.effects.StringUnboundedTest|tests.countdownlatch.racy.BoundedSingleTest|tests.countdownlatch.racy.UnboundedSingleTest|tests.countdownlatch.waits.BoundedDoubleTest|tests.countdownlatch.waits.BoundedSingleTest|tests.countdownlatch.waits.UnboundedDoubleTest|tests.countdownlatch.waits.UnboundedSingleTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomics</testCaseName>
+	<!-- 14/82 org.openjdk.jcstress.tests.atomics: classes 13/tests 28(ac/ar:26/2)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomics.booleans.AtomicBooleanInitialValueTest|tests.atomics.integer.AtomicIntegerArrayInitialValueTest|tests.atomics.integer.AtomicIntegerArrayInterleaveTest|tests.atomics.integer.AtomicIntegerInitialValueTest|tests.atomics.longs.AtomicLongArrayInitialValueTest|tests.atomics.longs.AtomicLongArrayInterleaveTest|tests.atomics.longs.AtomicLongInitialValueTest|tests.atomics.booleans.AtomicBooleanPairwiseTests.CAS_CAS|tests.atomics.booleans.AtomicBooleanPairwiseTests.CAS_GetAndSet|tests.atomics.booleans.AtomicBooleanPairwiseTests.CAS_WCAS|tests.atomics.booleans.AtomicBooleanPairwiseTests.GetAndSet_GetAndSet|tests.atomics.booleans.AtomicBooleanPairwiseTests.GetAndSet_WCAS|tests.atomics.booleans.AtomicBooleanPairwiseTests.WCAS_WCAS"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.copy.clone</testCaseName>
+	<!-- 15/82 org.openjdk.jcstress.tests.copy.clone: classes 14/tests 28(ac/ar:28/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.copy.clone.objects.plain.BooleanTest|tests.copy.clone.objects.plain.ByteTest|tests.copy.clone.objects.plain.CharTest|tests.copy.clone.objects.plain.FloatTest|tests.copy.clone.objects.plain.IntTest|tests.copy.clone.objects.plain.ShortTest|tests.copy.clone.objects.plain.StringTest|tests.copy.clone.objects.volatiles.BooleanTest|tests.copy.clone.objects.volatiles.ByteTest|tests.copy.clone.objects.volatiles.CharTest|tests.copy.clone.objects.volatiles.FloatTest|tests.copy.clone.objects.volatiles.IntTest|tests.copy.clone.objects.volatiles.ShortTest|tests.copy.clone.objects.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.copy.manual</testCaseName>
+	<!-- 16/82 org.openjdk.jcstress.tests.copy.manual: classes 14/tests 28(ac/ar:28/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.copy.manual.objects.plain.BooleanTest|tests.copy.manual.objects.plain.ByteTest|tests.copy.manual.objects.plain.CharTest|tests.copy.manual.objects.plain.FloatTest|tests.copy.manual.objects.plain.IntTest|tests.copy.manual.objects.plain.ShortTest|tests.copy.manual.objects.plain.StringTest|tests.copy.manual.objects.volatiles.BooleanTest|tests.copy.manual.objects.volatiles.ByteTest|tests.copy.manual.objects.volatiles.CharTest|tests.copy.manual.objects.volatiles.FloatTest|tests.copy.manual.objects.volatiles.IntTest|tests.copy.manual.objects.volatiles.ShortTest|tests.copy.manual.objects.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.singletons</testCaseName>
+	<!-- 17/82 org.openjdk.jcstress.tests.singletons: classes 14/tests 28(ac/ar:28/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.singletons.FinalWrapper.Safe|tests.singletons.FinalWrapper.Unsafe|tests.singletons.Holder.Safe|tests.singletons.Holder.Unsafe|tests.singletons.SafeDCL.Safe|tests.singletons.SafeDCL.Unsafe|tests.singletons.SafeLocalDCL.Safe|tests.singletons.SafeLocalDCL.Unsafe|tests.singletons.SynchronizedCL.Safe|tests.singletons.SynchronizedCL.Unsafe|tests.singletons.UnsafeDCL.Safe|tests.singletons.UnsafeDCL.Unsafe|tests.singletons.UnsafeLocalDCL.Safe|tests.singletons.UnsafeLocalDCL.Unsafe"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.defaultValues</testCaseName>
+	<!-- 18/82 org.openjdk.jcstress.tests.defaultValues: classes 18/tests 36(ac/ar:36/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.defaultValues.fields.sync.BooleanTest|tests.defaultValues.fields.sync.ByteTest|tests.defaultValues.fields.sync.CharTest|tests.defaultValues.fields.sync.DoubleTest|tests.defaultValues.fields.sync.FloatTest|tests.defaultValues.fields.sync.IntTest|tests.defaultValues.fields.sync.LongTest|tests.defaultValues.fields.sync.ShortTest|tests.defaultValues.fields.sync.StringTest|tests.defaultValues.fields.volatiles.BooleanTest|tests.defaultValues.fields.volatiles.ByteTest|tests.defaultValues.fields.volatiles.CharTest|tests.defaultValues.fields.volatiles.DoubleTest|tests.defaultValues.fields.volatiles.FloatTest|tests.defaultValues.fields.volatiles.IntTest|tests.defaultValues.fields.volatiles.LongTest|tests.defaultValues.fields.volatiles.ShortTest|tests.defaultValues.fields.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.defaultValues.arrays</testCaseName>
+	<!-- 19/82 org.openjdk.jcstress.tests.defaultValues.arrays: classes 18/tests 36(ac/ar:36/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.defaultValues.arrays.large.sync.BooleanTest|tests.defaultValues.arrays.large.sync.ByteTest|tests.defaultValues.arrays.large.sync.CharTest|tests.defaultValues.arrays.large.sync.DoubleTest|tests.defaultValues.arrays.large.sync.FloatTest|tests.defaultValues.arrays.large.sync.IntTest|tests.defaultValues.arrays.large.sync.LongTest|tests.defaultValues.arrays.large.sync.ShortTest|tests.defaultValues.arrays.large.sync.StringTest|tests.defaultValues.arrays.small.sync.BooleanTest|tests.defaultValues.arrays.small.sync.ByteTest|tests.defaultValues.arrays.small.sync.CharTest|tests.defaultValues.arrays.small.sync.DoubleTest|tests.defaultValues.arrays.small.sync.FloatTest|tests.defaultValues.arrays.small.sync.IntTest|tests.defaultValues.arrays.small.sync.LongTest|tests.defaultValues.arrays.small.sync.ShortTest|tests.defaultValues.arrays.small.sync.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.init.arrays</testCaseName>
+	<!-- 20/82 org.openjdk.jcstress.tests.init.arrays: classes 18/tests 36(ac/ar:36/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.init.arrays.large.sync.BooleanTest|tests.init.arrays.large.sync.ByteTest|tests.init.arrays.large.sync.CharTest|tests.init.arrays.large.sync.DoubleTest|tests.init.arrays.large.sync.FloatTest|tests.init.arrays.large.sync.IntTest|tests.init.arrays.large.sync.LongTest|tests.init.arrays.large.sync.ShortTest|tests.init.arrays.large.sync.StringTest|tests.init.arrays.small.sync.BooleanTest|tests.init.arrays.small.sync.ByteTest|tests.init.arrays.small.sync.CharTest|tests.init.arrays.small.sync.DoubleTest|tests.init.arrays.small.sync.FloatTest|tests.init.arrays.small.sync.IntTest|tests.init.arrays.small.sync.LongTest|tests.init.arrays.small.sync.ShortTest|tests.init.arrays.small.sync.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.initClass</testCaseName>
+	<!-- 21/82 org.openjdk.jcstress.tests.initClass: classes 18/tests 36(ac/ar:36/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.initClass.fields.sync.BooleanTest|tests.initClass.fields.sync.ByteTest|tests.initClass.fields.sync.CharTest|tests.initClass.fields.sync.DoubleTest|tests.initClass.fields.sync.FloatTest|tests.initClass.fields.sync.IntTest|tests.initClass.fields.sync.LongTest|tests.initClass.fields.sync.ShortTest|tests.initClass.fields.sync.StringTest|tests.initClass.fields.volatiles.BooleanTest|tests.initClass.fields.volatiles.ByteTest|tests.initClass.fields.volatiles.CharTest|tests.initClass.fields.volatiles.DoubleTest|tests.initClass.fields.volatiles.FloatTest|tests.initClass.fields.volatiles.IntTest|tests.initClass.fields.volatiles.LongTest|tests.initClass.fields.volatiles.ShortTest|tests.initClass.fields.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.initClass.arrays</testCaseName>
+	<!-- 22/82 org.openjdk.jcstress.tests.initClass.arrays: classes 18/tests 36(ac/ar:36/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.initClass.arrays.large.sync.BooleanTest|tests.initClass.arrays.large.sync.ByteTest|tests.initClass.arrays.large.sync.CharTest|tests.initClass.arrays.large.sync.DoubleTest|tests.initClass.arrays.large.sync.FloatTest|tests.initClass.arrays.large.sync.IntTest|tests.initClass.arrays.large.sync.LongTest|tests.initClass.arrays.large.sync.ShortTest|tests.initClass.arrays.large.sync.StringTest|tests.initClass.arrays.small.sync.BooleanTest|tests.initClass.arrays.small.sync.ByteTest|tests.initClass.arrays.small.sync.CharTest|tests.initClass.arrays.small.sync.DoubleTest|tests.initClass.arrays.small.sync.FloatTest|tests.initClass.arrays.small.sync.IntTest|tests.initClass.arrays.small.sync.LongTest|tests.initClass.arrays.small.sync.ShortTest|tests.initClass.arrays.small.sync.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.initLen.arrays</testCaseName>
+	<!-- 23/82 org.openjdk.jcstress.tests.initLen.arrays: classes 18/tests 36(ac/ar:36/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.initLen.arrays.large.sync.BooleanTest|tests.initLen.arrays.large.sync.ByteTest|tests.initLen.arrays.large.sync.CharTest|tests.initLen.arrays.large.sync.DoubleTest|tests.initLen.arrays.large.sync.FloatTest|tests.initLen.arrays.large.sync.IntTest|tests.initLen.arrays.large.sync.LongTest|tests.initLen.arrays.large.sync.ShortTest|tests.initLen.arrays.large.sync.StringTest|tests.initLen.arrays.small.sync.BooleanTest|tests.initLen.arrays.small.sync.ByteTest|tests.initLen.arrays.small.sync.CharTest|tests.initLen.arrays.small.sync.DoubleTest|tests.initLen.arrays.small.sync.FloatTest|tests.initLen.arrays.small.sync.IntTest|tests.initLen.arrays.small.sync.LongTest|tests.initLen.arrays.small.sync.ShortTest|tests.initLen.arrays.small.sync.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.locks</testCaseName>
+	<!-- 24/82 org.openjdk.jcstress.tests.locks: classes 18/tests 36(ac/ar:36/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.locks.barriers.SyncBarrier0Test|tests.locks.barriers.SyncBarrier1Test|tests.locks.barriers.SyncBarrier2Test|tests.locks.barriers.SyncBarrier3Test|tests.locks.mutex.SynchronizedMutexPoolTest|tests.locks.mutex.SynchronizedMutexTest|tests.locks.stamped.StampedLockTransitionTests.OO_OO|tests.locks.stamped.StampedLockTransitionTests.OO_OR|tests.locks.stamped.StampedLockTransitionTests.OO_OW|tests.locks.stamped.StampedLockTransitionTests.OR_OW|tests.locks.stamped.StampedLockTransitionTests.RO_RO|tests.locks.stamped.StampedLockTransitionTests.RO_RR|tests.locks.stamped.StampedLockTransitionTests.RO_RW|tests.locks.stamped.StampedLockTransitionTests.RR_RW|tests.locks.stamped.StampedLockTransitionTests.WO_WO|tests.locks.stamped.StampedLockTransitionTests.WO_WR|tests.locks.stamped.StampedLockTransitionTests.WO_WW|tests.locks.stamped.StampedLockTransitionTests.WR_WW"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.volatiles</testCaseName>
+	<!-- 25/82 org.openjdk.jcstress.tests.volatiles: classes 15/tests 39(ac/ar:39/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.volatiles.DekkerTest|tests.volatiles.DoubleVolatileTest|tests.volatiles.LazySetTransitivityTest|tests.volatiles.ObservedVolatileBarrierTest|tests.volatiles.OpaqueIRIWTest|tests.volatiles.PowerSCViolation|tests.volatiles.ReadAfterReadTest|tests.volatiles.ReadAfterVolatileReadTest|tests.volatiles.ReadTwiceOverVolatileReadTest|tests.volatiles.RelaxedIRIWTest|tests.volatiles.ScalarReplacedVolatileBarrierTest|tests.volatiles.UnobservedVolatileBarrierTest|tests.volatiles.VolatileAcquireReleaseTest|tests.volatiles.VolatileIRIWTest|tests.volatiles.VolatileIncrementAtomicityTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.causality</testCaseName>
+	<!-- 26/82 org.openjdk.jcstress.tests.causality: classes 18/tests 43(ac/ar:43/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.causality.Test1|tests.causality.Test10|tests.causality.Test11|tests.causality.Test12|tests.causality.Test13|tests.causality.Test14|tests.causality.Test15|tests.causality.Test16|tests.causality.Test17|tests.causality.Test18|tests.causality.Test2|tests.causality.Test3|tests.causality.Test4|tests.causality.Test5|tests.causality.Test6|tests.causality.Test7|tests.causality.Test8|tests.causality.Test9"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.init</testCaseName>
+	<!-- 27/82 org.openjdk.jcstress.tests.init: classes 26/tests 52(ac/ar:52/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.init.fields.sync.BooleanTest|tests.init.fields.sync.ByteTest|tests.init.fields.sync.CharTest|tests.init.fields.sync.DoubleTest|tests.init.fields.sync.FloatTest|tests.init.fields.sync.IntTest|tests.init.fields.sync.LongTest|tests.init.fields.sync.ShortTest|tests.init.fields.sync.StringTest|tests.init.fields.volatiles.BooleanTest|tests.init.fields.volatiles.ByteTest|tests.init.fields.volatiles.CharTest|tests.init.fields.volatiles.DoubleTest|tests.init.fields.volatiles.FloatTest|tests.init.fields.volatiles.IntTest|tests.init.fields.volatiles.LongTest|tests.init.fields.volatiles.ShortTest|tests.init.fields.volatiles.StringTest|tests.init.primitives.fenced.BooleanFencedTest|tests.init.primitives.fenced.ByteFencedTest|tests.init.primitives.fenced.CharFencedTest|tests.init.primitives.fenced.DoubleFencedTest|tests.init.primitives.fenced.FloatFencedTest|tests.init.primitives.fenced.IntFencedTest|tests.init.primitives.fenced.LongFencedTest|tests.init.primitives.fenced.ShortFencedTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.accessAtomic</testCaseName>
+	<!-- 28/82 org.openjdk.jcstress.tests.accessAtomic: classes 27/tests 54(ac/ar:54/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.accessAtomic.arrays.sync.BooleanTest|tests.accessAtomic.arrays.sync.ByteTest|tests.accessAtomic.arrays.sync.CharTest|tests.accessAtomic.arrays.sync.DoubleTest|tests.accessAtomic.arrays.sync.FloatTest|tests.accessAtomic.arrays.sync.IntTest|tests.accessAtomic.arrays.sync.LongTest|tests.accessAtomic.arrays.sync.ShortTest|tests.accessAtomic.arrays.sync.StringTest|tests.accessAtomic.fields.sync.BooleanTest|tests.accessAtomic.fields.sync.ByteTest|tests.accessAtomic.fields.sync.CharTest|tests.accessAtomic.fields.sync.DoubleTest|tests.accessAtomic.fields.sync.FloatTest|tests.accessAtomic.fields.sync.IntTest|tests.accessAtomic.fields.sync.LongTest|tests.accessAtomic.fields.sync.ShortTest|tests.accessAtomic.fields.sync.StringTest|tests.accessAtomic.fields.volatiles.BooleanTest|tests.accessAtomic.fields.volatiles.ByteTest|tests.accessAtomic.fields.volatiles.CharTest|tests.accessAtomic.fields.volatiles.DoubleTest|tests.accessAtomic.fields.volatiles.FloatTest|tests.accessAtomic.fields.volatiles.IntTest|tests.accessAtomic.fields.volatiles.LongTest|tests.accessAtomic.fields.volatiles.ShortTest|tests.accessAtomic.fields.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.accessAtomic.fields</testCaseName>
+	<!-- 29/82 org.openjdk.jcstress.tests.accessAtomic.fields: classes 18/tests 54(ac/ar:36/18)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.accessAtomic.fields.conflict.sync.BooleanTest|tests.accessAtomic.fields.conflict.sync.ByteTest|tests.accessAtomic.fields.conflict.sync.CharTest|tests.accessAtomic.fields.conflict.sync.DoubleTest|tests.accessAtomic.fields.conflict.sync.FloatTest|tests.accessAtomic.fields.conflict.sync.IntTest|tests.accessAtomic.fields.conflict.sync.LongTest|tests.accessAtomic.fields.conflict.sync.ShortTest|tests.accessAtomic.fields.conflict.sync.StringTest|tests.accessAtomic.fields.conflict.volatiles.BooleanTest|tests.accessAtomic.fields.conflict.volatiles.ByteTest|tests.accessAtomic.fields.conflict.volatiles.CharTest|tests.accessAtomic.fields.conflict.volatiles.DoubleTest|tests.accessAtomic.fields.conflict.volatiles.FloatTest|tests.accessAtomic.fields.conflict.volatiles.IntTest|tests.accessAtomic.fields.conflict.volatiles.LongTest|tests.accessAtomic.fields.conflict.volatiles.ShortTest|tests.accessAtomic.fields.conflict.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.coherence</testCaseName>
+	<!-- 30/82 org.openjdk.jcstress.tests.coherence: classes 27/tests 54(ac/ar:54/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.coherence.arrays.sync.BooleanTest|tests.coherence.arrays.sync.ByteTest|tests.coherence.arrays.sync.CharTest|tests.coherence.arrays.sync.DoubleTest|tests.coherence.arrays.sync.FloatTest|tests.coherence.arrays.sync.IntTest|tests.coherence.arrays.sync.LongTest|tests.coherence.arrays.sync.ShortTest|tests.coherence.arrays.sync.StringTest|tests.coherence.fields.sync.BooleanTest|tests.coherence.fields.sync.ByteTest|tests.coherence.fields.sync.CharTest|tests.coherence.fields.sync.DoubleTest|tests.coherence.fields.sync.FloatTest|tests.coherence.fields.sync.IntTest|tests.coherence.fields.sync.LongTest|tests.coherence.fields.sync.ShortTest|tests.coherence.fields.sync.StringTest|tests.coherence.fields.volatiles.BooleanTest|tests.coherence.fields.volatiles.ByteTest|tests.coherence.fields.volatiles.CharTest|tests.coherence.fields.volatiles.DoubleTest|tests.coherence.fields.volatiles.FloatTest|tests.coherence.fields.volatiles.IntTest|tests.coherence.fields.volatiles.LongTest|tests.coherence.fields.volatiles.ShortTest|tests.coherence.fields.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.tearing.arrays</testCaseName>
+	<!-- 31/82 org.openjdk.jcstress.tests.tearing.arrays: classes 18/tests 54(ac/ar:36/18)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.tearing.arrays.large.sync.BooleanTest|tests.tearing.arrays.large.sync.ByteTest|tests.tearing.arrays.large.sync.CharTest|tests.tearing.arrays.large.sync.DoubleTest|tests.tearing.arrays.large.sync.FloatTest|tests.tearing.arrays.large.sync.IntTest|tests.tearing.arrays.large.sync.LongTest|tests.tearing.arrays.large.sync.ShortTest|tests.tearing.arrays.large.sync.StringTest|tests.tearing.arrays.small.sync.BooleanTest|tests.tearing.arrays.small.sync.ByteTest|tests.tearing.arrays.small.sync.CharTest|tests.tearing.arrays.small.sync.DoubleTest|tests.tearing.arrays.small.sync.FloatTest|tests.tearing.arrays.small.sync.IntTest|tests.tearing.arrays.small.sync.LongTest|tests.tearing.arrays.small.sync.ShortTest|tests.tearing.arrays.small.sync.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.copy.arraycopy.arrays</testCaseName>
+	<!-- 32/82 org.openjdk.jcstress.tests.copy.arraycopy.arrays: classes 28/tests 56(ac/ar:56/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.copy.arraycopy.arrays.large.plain.BooleanTest|tests.copy.arraycopy.arrays.large.plain.ByteTest|tests.copy.arraycopy.arrays.large.plain.CharTest|tests.copy.arraycopy.arrays.large.plain.FloatTest|tests.copy.arraycopy.arrays.large.plain.IntTest|tests.copy.arraycopy.arrays.large.plain.ShortTest|tests.copy.arraycopy.arrays.large.plain.StringTest|tests.copy.arraycopy.arrays.large.volatiles.BooleanTest|tests.copy.arraycopy.arrays.large.volatiles.ByteTest|tests.copy.arraycopy.arrays.large.volatiles.CharTest|tests.copy.arraycopy.arrays.large.volatiles.FloatTest|tests.copy.arraycopy.arrays.large.volatiles.IntTest|tests.copy.arraycopy.arrays.large.volatiles.ShortTest|tests.copy.arraycopy.arrays.large.volatiles.StringTest|tests.copy.arraycopy.arrays.small.plain.BooleanTest|tests.copy.arraycopy.arrays.small.plain.ByteTest|tests.copy.arraycopy.arrays.small.plain.CharTest|tests.copy.arraycopy.arrays.small.plain.FloatTest|tests.copy.arraycopy.arrays.small.plain.IntTest|tests.copy.arraycopy.arrays.small.plain.ShortTest|tests.copy.arraycopy.arrays.small.plain.StringTest|tests.copy.arraycopy.arrays.small.volatiles.BooleanTest|tests.copy.arraycopy.arrays.small.volatiles.ByteTest|tests.copy.arraycopy.arrays.small.volatiles.CharTest|tests.copy.arraycopy.arrays.small.volatiles.FloatTest|tests.copy.arraycopy.arrays.small.volatiles.IntTest|tests.copy.arraycopy.arrays.small.volatiles.ShortTest|tests.copy.arraycopy.arrays.small.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.copy.clone.arrays</testCaseName>
+	<!-- 33/82 org.openjdk.jcstress.tests.copy.clone.arrays: classes 28/tests 56(ac/ar:56/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.copy.clone.arrays.large.plain.BooleanTest|tests.copy.clone.arrays.large.plain.ByteTest|tests.copy.clone.arrays.large.plain.CharTest|tests.copy.clone.arrays.large.plain.FloatTest|tests.copy.clone.arrays.large.plain.IntTest|tests.copy.clone.arrays.large.plain.ShortTest|tests.copy.clone.arrays.large.plain.StringTest|tests.copy.clone.arrays.large.volatiles.BooleanTest|tests.copy.clone.arrays.large.volatiles.ByteTest|tests.copy.clone.arrays.large.volatiles.CharTest|tests.copy.clone.arrays.large.volatiles.FloatTest|tests.copy.clone.arrays.large.volatiles.IntTest|tests.copy.clone.arrays.large.volatiles.ShortTest|tests.copy.clone.arrays.large.volatiles.StringTest|tests.copy.clone.arrays.small.plain.BooleanTest|tests.copy.clone.arrays.small.plain.ByteTest|tests.copy.clone.arrays.small.plain.CharTest|tests.copy.clone.arrays.small.plain.FloatTest|tests.copy.clone.arrays.small.plain.IntTest|tests.copy.clone.arrays.small.plain.ShortTest|tests.copy.clone.arrays.small.plain.StringTest|tests.copy.clone.arrays.small.volatiles.BooleanTest|tests.copy.clone.arrays.small.volatiles.ByteTest|tests.copy.clone.arrays.small.volatiles.CharTest|tests.copy.clone.arrays.small.volatiles.FloatTest|tests.copy.clone.arrays.small.volatiles.IntTest|tests.copy.clone.arrays.small.volatiles.ShortTest|tests.copy.clone.arrays.small.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.copy.copyof.arrays</testCaseName>
+	<!-- 34/82 org.openjdk.jcstress.tests.copy.copyof.arrays: classes 28/tests 56(ac/ar:56/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.copy.copyof.arrays.large.plain.BooleanTest|tests.copy.copyof.arrays.large.plain.ByteTest|tests.copy.copyof.arrays.large.plain.CharTest|tests.copy.copyof.arrays.large.plain.FloatTest|tests.copy.copyof.arrays.large.plain.IntTest|tests.copy.copyof.arrays.large.plain.ShortTest|tests.copy.copyof.arrays.large.plain.StringTest|tests.copy.copyof.arrays.large.volatiles.BooleanTest|tests.copy.copyof.arrays.large.volatiles.ByteTest|tests.copy.copyof.arrays.large.volatiles.CharTest|tests.copy.copyof.arrays.large.volatiles.FloatTest|tests.copy.copyof.arrays.large.volatiles.IntTest|tests.copy.copyof.arrays.large.volatiles.ShortTest|tests.copy.copyof.arrays.large.volatiles.StringTest|tests.copy.copyof.arrays.small.plain.BooleanTest|tests.copy.copyof.arrays.small.plain.ByteTest|tests.copy.copyof.arrays.small.plain.CharTest|tests.copy.copyof.arrays.small.plain.FloatTest|tests.copy.copyof.arrays.small.plain.IntTest|tests.copy.copyof.arrays.small.plain.ShortTest|tests.copy.copyof.arrays.small.plain.StringTest|tests.copy.copyof.arrays.small.volatiles.BooleanTest|tests.copy.copyof.arrays.small.volatiles.ByteTest|tests.copy.copyof.arrays.small.volatiles.CharTest|tests.copy.copyof.arrays.small.volatiles.FloatTest|tests.copy.copyof.arrays.small.volatiles.IntTest|tests.copy.copyof.arrays.small.volatiles.ShortTest|tests.copy.copyof.arrays.small.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.copy.manual.arrays</testCaseName>
+	<!-- 35/82 org.openjdk.jcstress.tests.copy.manual.arrays: classes 28/tests 56(ac/ar:56/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.copy.manual.arrays.large.plain.BooleanTest|tests.copy.manual.arrays.large.plain.ByteTest|tests.copy.manual.arrays.large.plain.CharTest|tests.copy.manual.arrays.large.plain.FloatTest|tests.copy.manual.arrays.large.plain.IntTest|tests.copy.manual.arrays.large.plain.ShortTest|tests.copy.manual.arrays.large.plain.StringTest|tests.copy.manual.arrays.large.volatiles.BooleanTest|tests.copy.manual.arrays.large.volatiles.ByteTest|tests.copy.manual.arrays.large.volatiles.CharTest|tests.copy.manual.arrays.large.volatiles.FloatTest|tests.copy.manual.arrays.large.volatiles.IntTest|tests.copy.manual.arrays.large.volatiles.ShortTest|tests.copy.manual.arrays.large.volatiles.StringTest|tests.copy.manual.arrays.small.plain.BooleanTest|tests.copy.manual.arrays.small.plain.ByteTest|tests.copy.manual.arrays.small.plain.CharTest|tests.copy.manual.arrays.small.plain.FloatTest|tests.copy.manual.arrays.small.plain.IntTest|tests.copy.manual.arrays.small.plain.ShortTest|tests.copy.manual.arrays.small.plain.StringTest|tests.copy.manual.arrays.small.volatiles.BooleanTest|tests.copy.manual.arrays.small.volatiles.ByteTest|tests.copy.manual.arrays.small.volatiles.CharTest|tests.copy.manual.arrays.small.volatiles.FloatTest|tests.copy.manual.arrays.small.volatiles.IntTest|tests.copy.manual.arrays.small.volatiles.ShortTest|tests.copy.manual.arrays.small.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.accessAtomic.varHandles.byteArray</testCaseName>
+	<!-- 36/82 org.openjdk.jcstress.tests.accessAtomic.varHandles.byteArray: classes 36/tests 72(ac/ar:72/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.accessAtomic.varHandles.byteArray.big.acqrel.CharTest|tests.accessAtomic.varHandles.byteArray.big.acqrel.DoubleTest|tests.accessAtomic.varHandles.byteArray.big.acqrel.FloatTest|tests.accessAtomic.varHandles.byteArray.big.acqrel.IntTest|tests.accessAtomic.varHandles.byteArray.big.acqrel.LongTest|tests.accessAtomic.varHandles.byteArray.big.acqrel.ShortTest|tests.accessAtomic.varHandles.byteArray.big.opaque.CharTest|tests.accessAtomic.varHandles.byteArray.big.opaque.DoubleTest|tests.accessAtomic.varHandles.byteArray.big.opaque.FloatTest|tests.accessAtomic.varHandles.byteArray.big.opaque.IntTest|tests.accessAtomic.varHandles.byteArray.big.opaque.LongTest|tests.accessAtomic.varHandles.byteArray.big.opaque.ShortTest|tests.accessAtomic.varHandles.byteArray.big.volatiles.CharTest|tests.accessAtomic.varHandles.byteArray.big.volatiles.DoubleTest|tests.accessAtomic.varHandles.byteArray.big.volatiles.FloatTest|tests.accessAtomic.varHandles.byteArray.big.volatiles.IntTest|tests.accessAtomic.varHandles.byteArray.big.volatiles.LongTest|tests.accessAtomic.varHandles.byteArray.big.volatiles.ShortTest|tests.accessAtomic.varHandles.byteArray.little.acqrel.CharTest|tests.accessAtomic.varHandles.byteArray.little.acqrel.DoubleTest|tests.accessAtomic.varHandles.byteArray.little.acqrel.FloatTest|tests.accessAtomic.varHandles.byteArray.little.acqrel.IntTest|tests.accessAtomic.varHandles.byteArray.little.acqrel.LongTest|tests.accessAtomic.varHandles.byteArray.little.acqrel.ShortTest|tests.accessAtomic.varHandles.byteArray.little.opaque.CharTest|tests.accessAtomic.varHandles.byteArray.little.opaque.DoubleTest|tests.accessAtomic.varHandles.byteArray.little.opaque.FloatTest|tests.accessAtomic.varHandles.byteArray.little.opaque.IntTest|tests.accessAtomic.varHandles.byteArray.little.opaque.LongTest|tests.accessAtomic.varHandles.byteArray.little.opaque.ShortTest|tests.accessAtomic.varHandles.byteArray.little.volatiles.CharTest|tests.accessAtomic.varHandles.byteArray.little.volatiles.DoubleTest|tests.accessAtomic.varHandles.byteArray.little.volatiles.FloatTest|tests.accessAtomic.varHandles.byteArray.little.volatiles.IntTest|tests.accessAtomic.varHandles.byteArray.little.volatiles.LongTest|tests.accessAtomic.varHandles.byteArray.little.volatiles.ShortTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.accessAtomic.varHandles.byteBuffer.direct</testCaseName>
+	<!-- 37/82 org.openjdk.jcstress.tests.accessAtomic.varHandles.byteBuffer.direct: classes 36/tests 72(ac/ar:72/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.accessAtomic.varHandles.byteBuffer.direct.big.acqrel.CharTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.acqrel.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.acqrel.FloatTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.acqrel.IntTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.acqrel.LongTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.acqrel.ShortTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.opaque.CharTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.opaque.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.opaque.FloatTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.opaque.IntTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.opaque.LongTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.opaque.ShortTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.volatiles.CharTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.volatiles.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.volatiles.FloatTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.volatiles.IntTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.volatiles.LongTest|tests.accessAtomic.varHandles.byteBuffer.direct.big.volatiles.ShortTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.acqrel.CharTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.acqrel.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.acqrel.FloatTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.acqrel.IntTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.acqrel.LongTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.acqrel.ShortTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.opaque.CharTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.opaque.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.opaque.FloatTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.opaque.IntTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.opaque.LongTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.opaque.ShortTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.volatiles.CharTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.volatiles.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.volatiles.FloatTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.volatiles.IntTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.volatiles.LongTest|tests.accessAtomic.varHandles.byteBuffer.direct.little.volatiles.ShortTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.accessAtomic.varHandles.byteBuffer.heap</testCaseName>
+	<!-- 38/82 org.openjdk.jcstress.tests.accessAtomic.varHandles.byteBuffer.heap: classes 36/tests 72(ac/ar:72/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.accessAtomic.varHandles.byteBuffer.heap.big.acqrel.CharTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.acqrel.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.acqrel.FloatTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.acqrel.IntTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.acqrel.LongTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.acqrel.ShortTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.opaque.CharTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.opaque.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.opaque.FloatTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.opaque.IntTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.opaque.LongTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.opaque.ShortTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.volatiles.CharTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.volatiles.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.volatiles.FloatTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.volatiles.IntTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.volatiles.LongTest|tests.accessAtomic.varHandles.byteBuffer.heap.big.volatiles.ShortTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.acqrel.CharTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.acqrel.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.acqrel.FloatTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.acqrel.IntTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.acqrel.LongTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.acqrel.ShortTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.opaque.CharTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.opaque.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.opaque.FloatTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.opaque.IntTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.opaque.LongTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.opaque.ShortTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.volatiles.CharTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.volatiles.DoubleTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.volatiles.FloatTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.volatiles.IntTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.volatiles.LongTest|tests.accessAtomic.varHandles.byteBuffer.heap.little.volatiles.ShortTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.coherence.varHandles.byteArray</testCaseName>
+	<!-- 39/82 org.openjdk.jcstress.tests.coherence.varHandles.byteArray: classes 36/tests 72(ac/ar:72/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.coherence.varHandles.byteArray.big.acqrel.CharTest|tests.coherence.varHandles.byteArray.big.acqrel.DoubleTest|tests.coherence.varHandles.byteArray.big.acqrel.FloatTest|tests.coherence.varHandles.byteArray.big.acqrel.IntTest|tests.coherence.varHandles.byteArray.big.acqrel.LongTest|tests.coherence.varHandles.byteArray.big.acqrel.ShortTest|tests.coherence.varHandles.byteArray.big.opaque.CharTest|tests.coherence.varHandles.byteArray.big.opaque.DoubleTest|tests.coherence.varHandles.byteArray.big.opaque.FloatTest|tests.coherence.varHandles.byteArray.big.opaque.IntTest|tests.coherence.varHandles.byteArray.big.opaque.LongTest|tests.coherence.varHandles.byteArray.big.opaque.ShortTest|tests.coherence.varHandles.byteArray.big.volatiles.CharTest|tests.coherence.varHandles.byteArray.big.volatiles.DoubleTest|tests.coherence.varHandles.byteArray.big.volatiles.FloatTest|tests.coherence.varHandles.byteArray.big.volatiles.IntTest|tests.coherence.varHandles.byteArray.big.volatiles.LongTest|tests.coherence.varHandles.byteArray.big.volatiles.ShortTest|tests.coherence.varHandles.byteArray.little.acqrel.CharTest|tests.coherence.varHandles.byteArray.little.acqrel.DoubleTest|tests.coherence.varHandles.byteArray.little.acqrel.FloatTest|tests.coherence.varHandles.byteArray.little.acqrel.IntTest|tests.coherence.varHandles.byteArray.little.acqrel.LongTest|tests.coherence.varHandles.byteArray.little.acqrel.ShortTest|tests.coherence.varHandles.byteArray.little.opaque.CharTest|tests.coherence.varHandles.byteArray.little.opaque.DoubleTest|tests.coherence.varHandles.byteArray.little.opaque.FloatTest|tests.coherence.varHandles.byteArray.little.opaque.IntTest|tests.coherence.varHandles.byteArray.little.opaque.LongTest|tests.coherence.varHandles.byteArray.little.opaque.ShortTest|tests.coherence.varHandles.byteArray.little.volatiles.CharTest|tests.coherence.varHandles.byteArray.little.volatiles.DoubleTest|tests.coherence.varHandles.byteArray.little.volatiles.FloatTest|tests.coherence.varHandles.byteArray.little.volatiles.IntTest|tests.coherence.varHandles.byteArray.little.volatiles.LongTest|tests.coherence.varHandles.byteArray.little.volatiles.ShortTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.coherence.varHandles.byteBuffer.direct</testCaseName>
+	<!-- 40/82 org.openjdk.jcstress.tests.coherence.varHandles.byteBuffer.direct: classes 36/tests 72(ac/ar:72/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.coherence.varHandles.byteBuffer.direct.big.acqrel.CharTest|tests.coherence.varHandles.byteBuffer.direct.big.acqrel.DoubleTest|tests.coherence.varHandles.byteBuffer.direct.big.acqrel.FloatTest|tests.coherence.varHandles.byteBuffer.direct.big.acqrel.IntTest|tests.coherence.varHandles.byteBuffer.direct.big.acqrel.LongTest|tests.coherence.varHandles.byteBuffer.direct.big.acqrel.ShortTest|tests.coherence.varHandles.byteBuffer.direct.big.opaque.CharTest|tests.coherence.varHandles.byteBuffer.direct.big.opaque.DoubleTest|tests.coherence.varHandles.byteBuffer.direct.big.opaque.FloatTest|tests.coherence.varHandles.byteBuffer.direct.big.opaque.IntTest|tests.coherence.varHandles.byteBuffer.direct.big.opaque.LongTest|tests.coherence.varHandles.byteBuffer.direct.big.opaque.ShortTest|tests.coherence.varHandles.byteBuffer.direct.big.volatiles.CharTest|tests.coherence.varHandles.byteBuffer.direct.big.volatiles.DoubleTest|tests.coherence.varHandles.byteBuffer.direct.big.volatiles.FloatTest|tests.coherence.varHandles.byteBuffer.direct.big.volatiles.IntTest|tests.coherence.varHandles.byteBuffer.direct.big.volatiles.LongTest|tests.coherence.varHandles.byteBuffer.direct.big.volatiles.ShortTest|tests.coherence.varHandles.byteBuffer.direct.little.acqrel.CharTest|tests.coherence.varHandles.byteBuffer.direct.little.acqrel.DoubleTest|tests.coherence.varHandles.byteBuffer.direct.little.acqrel.FloatTest|tests.coherence.varHandles.byteBuffer.direct.little.acqrel.IntTest|tests.coherence.varHandles.byteBuffer.direct.little.acqrel.LongTest|tests.coherence.varHandles.byteBuffer.direct.little.acqrel.ShortTest|tests.coherence.varHandles.byteBuffer.direct.little.opaque.CharTest|tests.coherence.varHandles.byteBuffer.direct.little.opaque.DoubleTest|tests.coherence.varHandles.byteBuffer.direct.little.opaque.FloatTest|tests.coherence.varHandles.byteBuffer.direct.little.opaque.IntTest|tests.coherence.varHandles.byteBuffer.direct.little.opaque.LongTest|tests.coherence.varHandles.byteBuffer.direct.little.opaque.ShortTest|tests.coherence.varHandles.byteBuffer.direct.little.volatiles.CharTest|tests.coherence.varHandles.byteBuffer.direct.little.volatiles.DoubleTest|tests.coherence.varHandles.byteBuffer.direct.little.volatiles.FloatTest|tests.coherence.varHandles.byteBuffer.direct.little.volatiles.IntTest|tests.coherence.varHandles.byteBuffer.direct.little.volatiles.LongTest|tests.coherence.varHandles.byteBuffer.direct.little.volatiles.ShortTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.coherence.varHandles.byteBuffer.heap</testCaseName>
+	<!-- 41/82 org.openjdk.jcstress.tests.coherence.varHandles.byteBuffer.heap: classes 36/tests 72(ac/ar:72/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.coherence.varHandles.byteBuffer.heap.big.acqrel.CharTest|tests.coherence.varHandles.byteBuffer.heap.big.acqrel.DoubleTest|tests.coherence.varHandles.byteBuffer.heap.big.acqrel.FloatTest|tests.coherence.varHandles.byteBuffer.heap.big.acqrel.IntTest|tests.coherence.varHandles.byteBuffer.heap.big.acqrel.LongTest|tests.coherence.varHandles.byteBuffer.heap.big.acqrel.ShortTest|tests.coherence.varHandles.byteBuffer.heap.big.opaque.CharTest|tests.coherence.varHandles.byteBuffer.heap.big.opaque.DoubleTest|tests.coherence.varHandles.byteBuffer.heap.big.opaque.FloatTest|tests.coherence.varHandles.byteBuffer.heap.big.opaque.IntTest|tests.coherence.varHandles.byteBuffer.heap.big.opaque.LongTest|tests.coherence.varHandles.byteBuffer.heap.big.opaque.ShortTest|tests.coherence.varHandles.byteBuffer.heap.big.volatiles.CharTest|tests.coherence.varHandles.byteBuffer.heap.big.volatiles.DoubleTest|tests.coherence.varHandles.byteBuffer.heap.big.volatiles.FloatTest|tests.coherence.varHandles.byteBuffer.heap.big.volatiles.IntTest|tests.coherence.varHandles.byteBuffer.heap.big.volatiles.LongTest|tests.coherence.varHandles.byteBuffer.heap.big.volatiles.ShortTest|tests.coherence.varHandles.byteBuffer.heap.little.acqrel.CharTest|tests.coherence.varHandles.byteBuffer.heap.little.acqrel.DoubleTest|tests.coherence.varHandles.byteBuffer.heap.little.acqrel.FloatTest|tests.coherence.varHandles.byteBuffer.heap.little.acqrel.IntTest|tests.coherence.varHandles.byteBuffer.heap.little.acqrel.LongTest|tests.coherence.varHandles.byteBuffer.heap.little.acqrel.ShortTest|tests.coherence.varHandles.byteBuffer.heap.little.opaque.CharTest|tests.coherence.varHandles.byteBuffer.heap.little.opaque.DoubleTest|tests.coherence.varHandles.byteBuffer.heap.little.opaque.FloatTest|tests.coherence.varHandles.byteBuffer.heap.little.opaque.IntTest|tests.coherence.varHandles.byteBuffer.heap.little.opaque.LongTest|tests.coherence.varHandles.byteBuffer.heap.little.opaque.ShortTest|tests.coherence.varHandles.byteBuffer.heap.little.volatiles.CharTest|tests.coherence.varHandles.byteBuffer.heap.little.volatiles.DoubleTest|tests.coherence.varHandles.byteBuffer.heap.little.volatiles.FloatTest|tests.coherence.varHandles.byteBuffer.heap.little.volatiles.IntTest|tests.coherence.varHandles.byteBuffer.heap.little.volatiles.LongTest|tests.coherence.varHandles.byteBuffer.heap.little.volatiles.ShortTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.tearing</testCaseName>
+	<!-- 42/82 org.openjdk.jcstress.tests.tearing: classes 29/tests 87(ac/ar:58/29)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.tearing.ArrayInterleaveTest|tests.tearing.UnsafeArrayInterleaveTest|tests.tearing.UnsafeIntTearingTest|tests.tearing.buffers.ByteBufferInterleaveTest|tests.tearing.buffers.CharBufferInterleaveTest|tests.tearing.buffers.DirectByteBufferInterleaveTest|tests.tearing.buffers.DoubleBufferInterleaveTest|tests.tearing.buffers.FloatBufferInterleaveTest|tests.tearing.buffers.IntBufferInterleaveTest|tests.tearing.buffers.LongBufferInterleaveTest|tests.tearing.buffers.ShortBufferInterleaveTest|tests.tearing.fields.sync.BooleanTest|tests.tearing.fields.sync.ByteTest|tests.tearing.fields.sync.CharTest|tests.tearing.fields.sync.DoubleTest|tests.tearing.fields.sync.FloatTest|tests.tearing.fields.sync.IntTest|tests.tearing.fields.sync.LongTest|tests.tearing.fields.sync.ShortTest|tests.tearing.fields.sync.StringTest|tests.tearing.fields.volatiles.BooleanTest|tests.tearing.fields.volatiles.ByteTest|tests.tearing.fields.volatiles.CharTest|tests.tearing.fields.volatiles.DoubleTest|tests.tearing.fields.volatiles.FloatTest|tests.tearing.fields.volatiles.IntTest|tests.tearing.fields.volatiles.LongTest|tests.tearing.fields.volatiles.ShortTest|tests.tearing.fields.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.accessAtomic.varHandles</testCaseName>
+	<!-- 43/82 org.openjdk.jcstress.tests.accessAtomic.varHandles: classes 54/tests 108(ac/ar:108/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.accessAtomic.varHandles.arrays.acqrel.BooleanTest|tests.accessAtomic.varHandles.arrays.acqrel.ByteTest|tests.accessAtomic.varHandles.arrays.acqrel.CharTest|tests.accessAtomic.varHandles.arrays.acqrel.DoubleTest|tests.accessAtomic.varHandles.arrays.acqrel.FloatTest|tests.accessAtomic.varHandles.arrays.acqrel.IntTest|tests.accessAtomic.varHandles.arrays.acqrel.LongTest|tests.accessAtomic.varHandles.arrays.acqrel.ShortTest|tests.accessAtomic.varHandles.arrays.acqrel.StringTest|tests.accessAtomic.varHandles.arrays.opaque.BooleanTest|tests.accessAtomic.varHandles.arrays.opaque.ByteTest|tests.accessAtomic.varHandles.arrays.opaque.CharTest|tests.accessAtomic.varHandles.arrays.opaque.DoubleTest|tests.accessAtomic.varHandles.arrays.opaque.FloatTest|tests.accessAtomic.varHandles.arrays.opaque.IntTest|tests.accessAtomic.varHandles.arrays.opaque.LongTest|tests.accessAtomic.varHandles.arrays.opaque.ShortTest|tests.accessAtomic.varHandles.arrays.opaque.StringTest|tests.accessAtomic.varHandles.arrays.volatiles.BooleanTest|tests.accessAtomic.varHandles.arrays.volatiles.ByteTest|tests.accessAtomic.varHandles.arrays.volatiles.CharTest|tests.accessAtomic.varHandles.arrays.volatiles.DoubleTest|tests.accessAtomic.varHandles.arrays.volatiles.FloatTest|tests.accessAtomic.varHandles.arrays.volatiles.IntTest|tests.accessAtomic.varHandles.arrays.volatiles.LongTest|tests.accessAtomic.varHandles.arrays.volatiles.ShortTest|tests.accessAtomic.varHandles.arrays.volatiles.StringTest|tests.accessAtomic.varHandles.fields.acqrel.BooleanTest|tests.accessAtomic.varHandles.fields.acqrel.ByteTest|tests.accessAtomic.varHandles.fields.acqrel.CharTest|tests.accessAtomic.varHandles.fields.acqrel.DoubleTest|tests.accessAtomic.varHandles.fields.acqrel.FloatTest|tests.accessAtomic.varHandles.fields.acqrel.IntTest|tests.accessAtomic.varHandles.fields.acqrel.LongTest|tests.accessAtomic.varHandles.fields.acqrel.ShortTest|tests.accessAtomic.varHandles.fields.acqrel.StringTest|tests.accessAtomic.varHandles.fields.opaque.BooleanTest|tests.accessAtomic.varHandles.fields.opaque.ByteTest|tests.accessAtomic.varHandles.fields.opaque.CharTest|tests.accessAtomic.varHandles.fields.opaque.DoubleTest|tests.accessAtomic.varHandles.fields.opaque.FloatTest|tests.accessAtomic.varHandles.fields.opaque.IntTest|tests.accessAtomic.varHandles.fields.opaque.LongTest|tests.accessAtomic.varHandles.fields.opaque.ShortTest|tests.accessAtomic.varHandles.fields.opaque.StringTest|tests.accessAtomic.varHandles.fields.volatiles.BooleanTest|tests.accessAtomic.varHandles.fields.volatiles.ByteTest|tests.accessAtomic.varHandles.fields.volatiles.CharTest|tests.accessAtomic.varHandles.fields.volatiles.DoubleTest|tests.accessAtomic.varHandles.fields.volatiles.FloatTest|tests.accessAtomic.varHandles.fields.volatiles.IntTest|tests.accessAtomic.varHandles.fields.volatiles.LongTest|tests.accessAtomic.varHandles.fields.volatiles.ShortTest|tests.accessAtomic.varHandles.fields.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomicity.varHandles.arrays.WeakCASContendStrongTest</testCaseName>
+	<!-- 44/82 org.openjdk.jcstress.tests.atomicity.varHandles.arrays.WeakCASContendStrongTest: classes 36/tests 108(ac/ar:72/36)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetAcquireBoolean|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetAcquireByte|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetAcquireChar|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetAcquireDouble|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetAcquireLong|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetAcquireShort|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetAcquireString|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetBoolean|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetByte|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetChar|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetDouble|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetInt|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetLong|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetPlainBoolean|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetPlainByte|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetPlainChar|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetPlainDouble|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetPlainLong|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetPlainShort|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetPlainString|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetReleaseBoolean|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetReleaseByte|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetReleaseChar|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetReleaseDouble|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetReleaseLong|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetReleaseShort|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetReleaseString|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetShort|tests.atomicity.varHandles.arrays.WeakCASContendStrongTest.WeakCompareAndSetString"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomicity.varHandles.arrays.WeakCASTest</testCaseName>
+	<!-- 45/82 org.openjdk.jcstress.tests.atomicity.varHandles.arrays.WeakCASTest: classes 36/tests 108(ac/ar:72/36)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetAcquireBoolean|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetAcquireByte|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetAcquireChar|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetAcquireDouble|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetAcquireLong|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetAcquireShort|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetAcquireString|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetBoolean|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetByte|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetChar|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetDouble|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetInt|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetLong|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetPlainBoolean|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetPlainByte|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetPlainChar|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetPlainDouble|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetPlainLong|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetPlainShort|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetPlainString|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetReleaseBoolean|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetReleaseByte|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetReleaseChar|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetReleaseDouble|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetReleaseLong|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetReleaseShort|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetReleaseString|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetShort|tests.atomicity.varHandles.arrays.WeakCASTest.WeakCompareAndSetString"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomicity.varHandles.fields.WeakCASContendStrongTest</testCaseName>
+	<!-- 46/82 org.openjdk.jcstress.tests.atomicity.varHandles.fields.WeakCASContendStrongTest: classes 36/tests 108(ac/ar:72/36)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetAcquireBoolean|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetAcquireByte|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetAcquireChar|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetAcquireDouble|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetAcquireLong|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetAcquireShort|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetAcquireString|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetBoolean|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetByte|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetChar|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetDouble|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetInt|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetLong|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetPlainBoolean|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetPlainByte|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetPlainChar|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetPlainDouble|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetPlainLong|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetPlainShort|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetPlainString|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetReleaseBoolean|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetReleaseByte|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetReleaseChar|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetReleaseDouble|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetReleaseLong|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetReleaseShort|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetReleaseString|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetShort|tests.atomicity.varHandles.fields.WeakCASContendStrongTest.WeakCompareAndSetString"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomicity.varHandles.fields.WeakCASTest</testCaseName>
+	<!-- 47/82 org.openjdk.jcstress.tests.atomicity.varHandles.fields.WeakCASTest: classes 36/tests 108(ac/ar:72/36)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetAcquireBoolean|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetAcquireByte|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetAcquireChar|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetAcquireDouble|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetAcquireLong|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetAcquireShort|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetAcquireString|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetBoolean|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetByte|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetChar|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetDouble|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetInt|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetLong|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetPlainBoolean|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetPlainByte|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetPlainChar|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetPlainDouble|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetPlainLong|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetPlainShort|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetPlainString|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetReleaseBoolean|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetReleaseByte|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetReleaseChar|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetReleaseDouble|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetReleaseLong|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetReleaseShort|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetReleaseString|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetShort|tests.atomicity.varHandles.fields.WeakCASTest.WeakCompareAndSetString"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.coherence.varHandles</testCaseName>
+	<!-- 48/82 org.openjdk.jcstress.tests.coherence.varHandles: classes 54/tests 108(ac/ar:108/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.coherence.varHandles.arrays.acqrel.BooleanTest|tests.coherence.varHandles.arrays.acqrel.ByteTest|tests.coherence.varHandles.arrays.acqrel.CharTest|tests.coherence.varHandles.arrays.acqrel.DoubleTest|tests.coherence.varHandles.arrays.acqrel.FloatTest|tests.coherence.varHandles.arrays.acqrel.IntTest|tests.coherence.varHandles.arrays.acqrel.LongTest|tests.coherence.varHandles.arrays.acqrel.ShortTest|tests.coherence.varHandles.arrays.acqrel.StringTest|tests.coherence.varHandles.arrays.opaque.BooleanTest|tests.coherence.varHandles.arrays.opaque.ByteTest|tests.coherence.varHandles.arrays.opaque.CharTest|tests.coherence.varHandles.arrays.opaque.DoubleTest|tests.coherence.varHandles.arrays.opaque.FloatTest|tests.coherence.varHandles.arrays.opaque.IntTest|tests.coherence.varHandles.arrays.opaque.LongTest|tests.coherence.varHandles.arrays.opaque.ShortTest|tests.coherence.varHandles.arrays.opaque.StringTest|tests.coherence.varHandles.arrays.volatiles.BooleanTest|tests.coherence.varHandles.arrays.volatiles.ByteTest|tests.coherence.varHandles.arrays.volatiles.CharTest|tests.coherence.varHandles.arrays.volatiles.DoubleTest|tests.coherence.varHandles.arrays.volatiles.FloatTest|tests.coherence.varHandles.arrays.volatiles.IntTest|tests.coherence.varHandles.arrays.volatiles.LongTest|tests.coherence.varHandles.arrays.volatiles.ShortTest|tests.coherence.varHandles.arrays.volatiles.StringTest|tests.coherence.varHandles.fields.acqrel.BooleanTest|tests.coherence.varHandles.fields.acqrel.ByteTest|tests.coherence.varHandles.fields.acqrel.CharTest|tests.coherence.varHandles.fields.acqrel.DoubleTest|tests.coherence.varHandles.fields.acqrel.FloatTest|tests.coherence.varHandles.fields.acqrel.IntTest|tests.coherence.varHandles.fields.acqrel.LongTest|tests.coherence.varHandles.fields.acqrel.ShortTest|tests.coherence.varHandles.fields.acqrel.StringTest|tests.coherence.varHandles.fields.opaque.BooleanTest|tests.coherence.varHandles.fields.opaque.ByteTest|tests.coherence.varHandles.fields.opaque.CharTest|tests.coherence.varHandles.fields.opaque.DoubleTest|tests.coherence.varHandles.fields.opaque.FloatTest|tests.coherence.varHandles.fields.opaque.IntTest|tests.coherence.varHandles.fields.opaque.LongTest|tests.coherence.varHandles.fields.opaque.ShortTest|tests.coherence.varHandles.fields.opaque.StringTest|tests.coherence.varHandles.fields.volatiles.BooleanTest|tests.coherence.varHandles.fields.volatiles.ByteTest|tests.coherence.varHandles.fields.volatiles.CharTest|tests.coherence.varHandles.fields.volatiles.DoubleTest|tests.coherence.varHandles.fields.volatiles.FloatTest|tests.coherence.varHandles.fields.volatiles.IntTest|tests.coherence.varHandles.fields.volatiles.LongTest|tests.coherence.varHandles.fields.volatiles.ShortTest|tests.coherence.varHandles.fields.volatiles.StringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomics.integer.AtomicIntegerArrayPairwiseTests</testCaseName>
+	<!-- 49/82 org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerArrayPairwiseTests: classes 55/tests 111(ac/ar:110/1)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomics.integer.AtomicIntegerArrayPairwiseTests.AddAndGet_AddAndGet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.AddAndGet_CAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.AddAndGet_DecAndGet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.AddAndGet_GetAndAdd|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.AddAndGet_GetAndDec|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.AddAndGet_GetAndInc|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.AddAndGet_GetAndSet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.AddAndGet_IncAndGet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.AddAndGet_Set|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.AddAndGet_WCAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.CAS_CAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.CAS_Set|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.CAS_WCAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.DecAndGet_CAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.DecAndGet_DecAndGet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.DecAndGet_GetAndAdd|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.DecAndGet_GetAndDec|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.DecAndGet_GetAndInc|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.DecAndGet_GetAndSet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.DecAndGet_IncAndGet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.DecAndGet_Set|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.DecAndGet_WCAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndAdd_CAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndAdd_GetAndAdd|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndAdd_GetAndDec|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndAdd_GetAndInc|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndAdd_GetAndSet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndAdd_IncAndGet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndAdd_Set|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndAdd_WCAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndDec_CAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndDec_GetAndDec|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndDec_GetAndInc|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndDec_GetAndSet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndDec_IncAndGet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndDec_Set|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndDec_WCAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndInc_CAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndInc_GetAndInc|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndInc_GetAndSet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndInc_IncAndGet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndInc_Set|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndInc_WCAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndSet_CAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndSet_GetAndSet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndSet_IncAndGet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndSet_Set|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.GetAndSet_WCAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.IncAndGet_CAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.IncAndGet_IncAndGet|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.IncAndGet_Set|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.IncAndGet_WCAS|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.Set_Set|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.WCAS_Set|tests.atomics.integer.AtomicIntegerArrayPairwiseTests.WCAS_WCAS"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests</testCaseName>
+	<!-- 50/82 org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests: classes 55/tests 111(ac/ar:110/1)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.AddAndGet_AddAndGet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.AddAndGet_CAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.AddAndGet_DecAndGet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.AddAndGet_GetAndAdd|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.AddAndGet_GetAndDec|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.AddAndGet_GetAndInc|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.AddAndGet_GetAndSet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.AddAndGet_IncAndGet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.AddAndGet_Set|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.AddAndGet_WCAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.CAS_CAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.CAS_Set|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.CAS_WCAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.DecAndGet_CAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.DecAndGet_DecAndGet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.DecAndGet_GetAndAdd|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.DecAndGet_GetAndDec|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.DecAndGet_GetAndInc|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.DecAndGet_GetAndSet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.DecAndGet_IncAndGet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.DecAndGet_Set|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.DecAndGet_WCAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndAdd_CAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndAdd_GetAndAdd|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndAdd_GetAndDec|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndAdd_GetAndInc|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndAdd_GetAndSet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndAdd_IncAndGet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndAdd_Set|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndAdd_WCAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndDec_CAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndDec_GetAndDec|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndDec_GetAndInc|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndDec_GetAndSet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndDec_IncAndGet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndDec_Set|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndDec_WCAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndInc_CAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndInc_GetAndInc|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndInc_GetAndSet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndInc_IncAndGet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndInc_Set|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndInc_WCAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndSet_CAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndSet_GetAndSet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndSet_IncAndGet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndSet_Set|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.GetAndSet_WCAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.IncAndGet_CAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.IncAndGet_IncAndGet|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.IncAndGet_Set|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.IncAndGet_WCAS|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.Set_Set|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.WCAS_Set|tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests.WCAS_WCAS"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomics.integer.AtomicIntegerPairwiseTests</testCaseName>
+	<!-- 51/82 org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests: classes 55/tests 111(ac/ar:110/1)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomics.integer.AtomicIntegerPairwiseTests.AddAndGet_AddAndGet|tests.atomics.integer.AtomicIntegerPairwiseTests.AddAndGet_CAS|tests.atomics.integer.AtomicIntegerPairwiseTests.AddAndGet_DecAndGet|tests.atomics.integer.AtomicIntegerPairwiseTests.AddAndGet_GetAndAdd|tests.atomics.integer.AtomicIntegerPairwiseTests.AddAndGet_GetAndDec|tests.atomics.integer.AtomicIntegerPairwiseTests.AddAndGet_GetAndInc|tests.atomics.integer.AtomicIntegerPairwiseTests.AddAndGet_GetAndSet|tests.atomics.integer.AtomicIntegerPairwiseTests.AddAndGet_IncAndGet|tests.atomics.integer.AtomicIntegerPairwiseTests.AddAndGet_Set|tests.atomics.integer.AtomicIntegerPairwiseTests.AddAndGet_WCAS|tests.atomics.integer.AtomicIntegerPairwiseTests.CAS_CAS|tests.atomics.integer.AtomicIntegerPairwiseTests.CAS_Set|tests.atomics.integer.AtomicIntegerPairwiseTests.CAS_WCAS|tests.atomics.integer.AtomicIntegerPairwiseTests.DecAndGet_CAS|tests.atomics.integer.AtomicIntegerPairwiseTests.DecAndGet_DecAndGet|tests.atomics.integer.AtomicIntegerPairwiseTests.DecAndGet_GetAndAdd|tests.atomics.integer.AtomicIntegerPairwiseTests.DecAndGet_GetAndDec|tests.atomics.integer.AtomicIntegerPairwiseTests.DecAndGet_GetAndInc|tests.atomics.integer.AtomicIntegerPairwiseTests.DecAndGet_GetAndSet|tests.atomics.integer.AtomicIntegerPairwiseTests.DecAndGet_IncAndGet|tests.atomics.integer.AtomicIntegerPairwiseTests.DecAndGet_Set|tests.atomics.integer.AtomicIntegerPairwiseTests.DecAndGet_WCAS|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndAdd_CAS|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndAdd_GetAndAdd|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndAdd_GetAndDec|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndAdd_GetAndInc|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndAdd_GetAndSet|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndAdd_IncAndGet|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndAdd_Set|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndAdd_WCAS|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndDec_CAS|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndDec_GetAndDec|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndDec_GetAndInc|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndDec_GetAndSet|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndDec_IncAndGet|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndDec_Set|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndDec_WCAS|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndInc_CAS|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndInc_GetAndInc|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndInc_GetAndSet|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndInc_IncAndGet|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndInc_Set|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndInc_WCAS|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndSet_CAS|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndSet_GetAndSet|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndSet_IncAndGet|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndSet_Set|tests.atomics.integer.AtomicIntegerPairwiseTests.GetAndSet_WCAS|tests.atomics.integer.AtomicIntegerPairwiseTests.IncAndGet_CAS|tests.atomics.integer.AtomicIntegerPairwiseTests.IncAndGet_IncAndGet|tests.atomics.integer.AtomicIntegerPairwiseTests.IncAndGet_Set|tests.atomics.integer.AtomicIntegerPairwiseTests.IncAndGet_WCAS|tests.atomics.integer.AtomicIntegerPairwiseTests.Set_Set|tests.atomics.integer.AtomicIntegerPairwiseTests.WCAS_Set|tests.atomics.integer.AtomicIntegerPairwiseTests.WCAS_WCAS"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomics.longs.AtomicLongArrayPairwiseTests</testCaseName>
+	<!-- 52/82 org.openjdk.jcstress.tests.atomics.longs.AtomicLongArrayPairwiseTests: classes 55/tests 111(ac/ar:110/1)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomics.longs.AtomicLongArrayPairwiseTests.AddAndGet_AddAndGet|tests.atomics.longs.AtomicLongArrayPairwiseTests.AddAndGet_CAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.AddAndGet_DecAndGet|tests.atomics.longs.AtomicLongArrayPairwiseTests.AddAndGet_GetAndAdd|tests.atomics.longs.AtomicLongArrayPairwiseTests.AddAndGet_GetAndDec|tests.atomics.longs.AtomicLongArrayPairwiseTests.AddAndGet_GetAndInc|tests.atomics.longs.AtomicLongArrayPairwiseTests.AddAndGet_GetAndSet|tests.atomics.longs.AtomicLongArrayPairwiseTests.AddAndGet_IncAndGet|tests.atomics.longs.AtomicLongArrayPairwiseTests.AddAndGet_Set|tests.atomics.longs.AtomicLongArrayPairwiseTests.AddAndGet_WCAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.CAS_CAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.CAS_Set|tests.atomics.longs.AtomicLongArrayPairwiseTests.CAS_WCAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.DecAndGet_CAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.DecAndGet_DecAndGet|tests.atomics.longs.AtomicLongArrayPairwiseTests.DecAndGet_GetAndAdd|tests.atomics.longs.AtomicLongArrayPairwiseTests.DecAndGet_GetAndDec|tests.atomics.longs.AtomicLongArrayPairwiseTests.DecAndGet_GetAndInc|tests.atomics.longs.AtomicLongArrayPairwiseTests.DecAndGet_GetAndSet|tests.atomics.longs.AtomicLongArrayPairwiseTests.DecAndGet_IncAndGet|tests.atomics.longs.AtomicLongArrayPairwiseTests.DecAndGet_Set|tests.atomics.longs.AtomicLongArrayPairwiseTests.DecAndGet_WCAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndAdd_CAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndAdd_GetAndAdd|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndAdd_GetAndDec|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndAdd_GetAndInc|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndAdd_GetAndSet|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndAdd_IncAndGet|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndAdd_Set|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndAdd_WCAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndDec_CAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndDec_GetAndDec|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndDec_GetAndInc|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndDec_GetAndSet|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndDec_IncAndGet|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndDec_Set|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndDec_WCAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndInc_CAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndInc_GetAndInc|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndInc_GetAndSet|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndInc_IncAndGet|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndInc_Set|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndInc_WCAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndSet_CAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndSet_GetAndSet|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndSet_IncAndGet|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndSet_Set|tests.atomics.longs.AtomicLongArrayPairwiseTests.GetAndSet_WCAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.IncAndGet_CAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.IncAndGet_IncAndGet|tests.atomics.longs.AtomicLongArrayPairwiseTests.IncAndGet_Set|tests.atomics.longs.AtomicLongArrayPairwiseTests.IncAndGet_WCAS|tests.atomics.longs.AtomicLongArrayPairwiseTests.Set_Set|tests.atomics.longs.AtomicLongArrayPairwiseTests.WCAS_Set|tests.atomics.longs.AtomicLongArrayPairwiseTests.WCAS_WCAS"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomics.longs.AtomicLongFieldUpdaterPairwiseTests</testCaseName>
+	<!-- 53/82 org.openjdk.jcstress.tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests: classes 55/tests 111(ac/ar:110/1)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.AddAndGet_AddAndGet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.AddAndGet_CAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.AddAndGet_DecAndGet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.AddAndGet_GetAndAdd|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.AddAndGet_GetAndDec|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.AddAndGet_GetAndInc|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.AddAndGet_GetAndSet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.AddAndGet_IncAndGet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.AddAndGet_Set|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.AddAndGet_WCAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.CAS_CAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.CAS_Set|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.CAS_WCAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.DecAndGet_CAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.DecAndGet_DecAndGet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.DecAndGet_GetAndAdd|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.DecAndGet_GetAndDec|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.DecAndGet_GetAndInc|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.DecAndGet_GetAndSet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.DecAndGet_IncAndGet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.DecAndGet_Set|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.DecAndGet_WCAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndAdd_CAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndAdd_GetAndAdd|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndAdd_GetAndDec|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndAdd_GetAndInc|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndAdd_GetAndSet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndAdd_IncAndGet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndAdd_Set|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndAdd_WCAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndDec_CAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndDec_GetAndDec|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndDec_GetAndInc|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndDec_GetAndSet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndDec_IncAndGet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndDec_Set|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndDec_WCAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndInc_CAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndInc_GetAndInc|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndInc_GetAndSet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndInc_IncAndGet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndInc_Set|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndInc_WCAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndSet_CAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndSet_GetAndSet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndSet_IncAndGet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndSet_Set|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.GetAndSet_WCAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.IncAndGet_CAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.IncAndGet_IncAndGet|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.IncAndGet_Set|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.IncAndGet_WCAS|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.Set_Set|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.WCAS_Set|tests.atomics.longs.AtomicLongFieldUpdaterPairwiseTests.WCAS_WCAS"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomics.longs.AtomicLongPairwiseTests</testCaseName>
+	<!-- 54/82 org.openjdk.jcstress.tests.atomics.longs.AtomicLongPairwiseTests: classes 55/tests 111(ac/ar:110/1)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomics.longs.AtomicLongPairwiseTests.AddAndGet_AddAndGet|tests.atomics.longs.AtomicLongPairwiseTests.AddAndGet_CAS|tests.atomics.longs.AtomicLongPairwiseTests.AddAndGet_DecAndGet|tests.atomics.longs.AtomicLongPairwiseTests.AddAndGet_GetAndAdd|tests.atomics.longs.AtomicLongPairwiseTests.AddAndGet_GetAndDec|tests.atomics.longs.AtomicLongPairwiseTests.AddAndGet_GetAndInc|tests.atomics.longs.AtomicLongPairwiseTests.AddAndGet_GetAndSet|tests.atomics.longs.AtomicLongPairwiseTests.AddAndGet_IncAndGet|tests.atomics.longs.AtomicLongPairwiseTests.AddAndGet_Set|tests.atomics.longs.AtomicLongPairwiseTests.AddAndGet_WCAS|tests.atomics.longs.AtomicLongPairwiseTests.CAS_CAS|tests.atomics.longs.AtomicLongPairwiseTests.CAS_Set|tests.atomics.longs.AtomicLongPairwiseTests.CAS_WCAS|tests.atomics.longs.AtomicLongPairwiseTests.DecAndGet_CAS|tests.atomics.longs.AtomicLongPairwiseTests.DecAndGet_DecAndGet|tests.atomics.longs.AtomicLongPairwiseTests.DecAndGet_GetAndAdd|tests.atomics.longs.AtomicLongPairwiseTests.DecAndGet_GetAndDec|tests.atomics.longs.AtomicLongPairwiseTests.DecAndGet_GetAndInc|tests.atomics.longs.AtomicLongPairwiseTests.DecAndGet_GetAndSet|tests.atomics.longs.AtomicLongPairwiseTests.DecAndGet_IncAndGet|tests.atomics.longs.AtomicLongPairwiseTests.DecAndGet_Set|tests.atomics.longs.AtomicLongPairwiseTests.DecAndGet_WCAS|tests.atomics.longs.AtomicLongPairwiseTests.GetAndAdd_CAS|tests.atomics.longs.AtomicLongPairwiseTests.GetAndAdd_GetAndAdd|tests.atomics.longs.AtomicLongPairwiseTests.GetAndAdd_GetAndDec|tests.atomics.longs.AtomicLongPairwiseTests.GetAndAdd_GetAndInc|tests.atomics.longs.AtomicLongPairwiseTests.GetAndAdd_GetAndSet|tests.atomics.longs.AtomicLongPairwiseTests.GetAndAdd_IncAndGet|tests.atomics.longs.AtomicLongPairwiseTests.GetAndAdd_Set|tests.atomics.longs.AtomicLongPairwiseTests.GetAndAdd_WCAS|tests.atomics.longs.AtomicLongPairwiseTests.GetAndDec_CAS|tests.atomics.longs.AtomicLongPairwiseTests.GetAndDec_GetAndDec|tests.atomics.longs.AtomicLongPairwiseTests.GetAndDec_GetAndInc|tests.atomics.longs.AtomicLongPairwiseTests.GetAndDec_GetAndSet|tests.atomics.longs.AtomicLongPairwiseTests.GetAndDec_IncAndGet|tests.atomics.longs.AtomicLongPairwiseTests.GetAndDec_Set|tests.atomics.longs.AtomicLongPairwiseTests.GetAndDec_WCAS|tests.atomics.longs.AtomicLongPairwiseTests.GetAndInc_CAS|tests.atomics.longs.AtomicLongPairwiseTests.GetAndInc_GetAndInc|tests.atomics.longs.AtomicLongPairwiseTests.GetAndInc_GetAndSet|tests.atomics.longs.AtomicLongPairwiseTests.GetAndInc_IncAndGet|tests.atomics.longs.AtomicLongPairwiseTests.GetAndInc_Set|tests.atomics.longs.AtomicLongPairwiseTests.GetAndInc_WCAS|tests.atomics.longs.AtomicLongPairwiseTests.GetAndSet_CAS|tests.atomics.longs.AtomicLongPairwiseTests.GetAndSet_GetAndSet|tests.atomics.longs.AtomicLongPairwiseTests.GetAndSet_IncAndGet|tests.atomics.longs.AtomicLongPairwiseTests.GetAndSet_Set|tests.atomics.longs.AtomicLongPairwiseTests.GetAndSet_WCAS|tests.atomics.longs.AtomicLongPairwiseTests.IncAndGet_CAS|tests.atomics.longs.AtomicLongPairwiseTests.IncAndGet_IncAndGet|tests.atomics.longs.AtomicLongPairwiseTests.IncAndGet_Set|tests.atomics.longs.AtomicLongPairwiseTests.IncAndGet_WCAS|tests.atomics.longs.AtomicLongPairwiseTests.Set_Set|tests.atomics.longs.AtomicLongPairwiseTests.WCAS_Set|tests.atomics.longs.AtomicLongPairwiseTests.WCAS_WCAS"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.fields.sync</testCaseName>
+	<!-- 55/82 org.openjdk.jcstress.tests.acqrel.fields.sync: classes 63/tests 126(ac/ar:126/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.fields.sync.BooleanBooleanTest|tests.acqrel.fields.sync.BooleanByteTest|tests.acqrel.fields.sync.BooleanCharTest|tests.acqrel.fields.sync.BooleanFloatTest|tests.acqrel.fields.sync.BooleanIntTest|tests.acqrel.fields.sync.BooleanShortTest|tests.acqrel.fields.sync.BooleanStringTest|tests.acqrel.fields.sync.ByteBooleanTest|tests.acqrel.fields.sync.ByteByteTest|tests.acqrel.fields.sync.ByteCharTest|tests.acqrel.fields.sync.ByteFloatTest|tests.acqrel.fields.sync.ByteIntTest|tests.acqrel.fields.sync.ByteShortTest|tests.acqrel.fields.sync.ByteStringTest|tests.acqrel.fields.sync.CharBooleanTest|tests.acqrel.fields.sync.CharByteTest|tests.acqrel.fields.sync.CharCharTest|tests.acqrel.fields.sync.CharFloatTest|tests.acqrel.fields.sync.CharIntTest|tests.acqrel.fields.sync.CharShortTest|tests.acqrel.fields.sync.CharStringTest|tests.acqrel.fields.sync.DoubleBooleanTest|tests.acqrel.fields.sync.DoubleByteTest|tests.acqrel.fields.sync.DoubleCharTest|tests.acqrel.fields.sync.DoubleFloatTest|tests.acqrel.fields.sync.DoubleIntTest|tests.acqrel.fields.sync.DoubleShortTest|tests.acqrel.fields.sync.DoubleStringTest|tests.acqrel.fields.sync.FloatBooleanTest|tests.acqrel.fields.sync.FloatByteTest|tests.acqrel.fields.sync.FloatCharTest|tests.acqrel.fields.sync.FloatFloatTest|tests.acqrel.fields.sync.FloatIntTest|tests.acqrel.fields.sync.FloatShortTest|tests.acqrel.fields.sync.FloatStringTest|tests.acqrel.fields.sync.IntBooleanTest|tests.acqrel.fields.sync.IntByteTest|tests.acqrel.fields.sync.IntCharTest|tests.acqrel.fields.sync.IntFloatTest|tests.acqrel.fields.sync.IntIntTest|tests.acqrel.fields.sync.IntShortTest|tests.acqrel.fields.sync.IntStringTest|tests.acqrel.fields.sync.LongBooleanTest|tests.acqrel.fields.sync.LongByteTest|tests.acqrel.fields.sync.LongCharTest|tests.acqrel.fields.sync.LongFloatTest|tests.acqrel.fields.sync.LongIntTest|tests.acqrel.fields.sync.LongShortTest|tests.acqrel.fields.sync.LongStringTest|tests.acqrel.fields.sync.ShortBooleanTest|tests.acqrel.fields.sync.ShortByteTest|tests.acqrel.fields.sync.ShortCharTest|tests.acqrel.fields.sync.ShortFloatTest|tests.acqrel.fields.sync.ShortIntTest|tests.acqrel.fields.sync.ShortShortTest|tests.acqrel.fields.sync.ShortStringTest|tests.acqrel.fields.sync.StringBooleanTest|tests.acqrel.fields.sync.StringByteTest|tests.acqrel.fields.sync.StringCharTest|tests.acqrel.fields.sync.StringFloatTest|tests.acqrel.fields.sync.StringIntTest|tests.acqrel.fields.sync.StringShortTest|tests.acqrel.fields.sync.StringStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.fields.volatiles</testCaseName>
+	<!-- 56/82 org.openjdk.jcstress.tests.acqrel.fields.volatiles: classes 63/tests 126(ac/ar:126/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.fields.volatiles.BooleanBooleanTest|tests.acqrel.fields.volatiles.BooleanByteTest|tests.acqrel.fields.volatiles.BooleanCharTest|tests.acqrel.fields.volatiles.BooleanFloatTest|tests.acqrel.fields.volatiles.BooleanIntTest|tests.acqrel.fields.volatiles.BooleanShortTest|tests.acqrel.fields.volatiles.BooleanStringTest|tests.acqrel.fields.volatiles.ByteBooleanTest|tests.acqrel.fields.volatiles.ByteByteTest|tests.acqrel.fields.volatiles.ByteCharTest|tests.acqrel.fields.volatiles.ByteFloatTest|tests.acqrel.fields.volatiles.ByteIntTest|tests.acqrel.fields.volatiles.ByteShortTest|tests.acqrel.fields.volatiles.ByteStringTest|tests.acqrel.fields.volatiles.CharBooleanTest|tests.acqrel.fields.volatiles.CharByteTest|tests.acqrel.fields.volatiles.CharCharTest|tests.acqrel.fields.volatiles.CharFloatTest|tests.acqrel.fields.volatiles.CharIntTest|tests.acqrel.fields.volatiles.CharShortTest|tests.acqrel.fields.volatiles.CharStringTest|tests.acqrel.fields.volatiles.DoubleBooleanTest|tests.acqrel.fields.volatiles.DoubleByteTest|tests.acqrel.fields.volatiles.DoubleCharTest|tests.acqrel.fields.volatiles.DoubleFloatTest|tests.acqrel.fields.volatiles.DoubleIntTest|tests.acqrel.fields.volatiles.DoubleShortTest|tests.acqrel.fields.volatiles.DoubleStringTest|tests.acqrel.fields.volatiles.FloatBooleanTest|tests.acqrel.fields.volatiles.FloatByteTest|tests.acqrel.fields.volatiles.FloatCharTest|tests.acqrel.fields.volatiles.FloatFloatTest|tests.acqrel.fields.volatiles.FloatIntTest|tests.acqrel.fields.volatiles.FloatShortTest|tests.acqrel.fields.volatiles.FloatStringTest|tests.acqrel.fields.volatiles.IntBooleanTest|tests.acqrel.fields.volatiles.IntByteTest|tests.acqrel.fields.volatiles.IntCharTest|tests.acqrel.fields.volatiles.IntFloatTest|tests.acqrel.fields.volatiles.IntIntTest|tests.acqrel.fields.volatiles.IntShortTest|tests.acqrel.fields.volatiles.IntStringTest|tests.acqrel.fields.volatiles.LongBooleanTest|tests.acqrel.fields.volatiles.LongByteTest|tests.acqrel.fields.volatiles.LongCharTest|tests.acqrel.fields.volatiles.LongFloatTest|tests.acqrel.fields.volatiles.LongIntTest|tests.acqrel.fields.volatiles.LongShortTest|tests.acqrel.fields.volatiles.LongStringTest|tests.acqrel.fields.volatiles.ShortBooleanTest|tests.acqrel.fields.volatiles.ShortByteTest|tests.acqrel.fields.volatiles.ShortCharTest|tests.acqrel.fields.volatiles.ShortFloatTest|tests.acqrel.fields.volatiles.ShortIntTest|tests.acqrel.fields.volatiles.ShortShortTest|tests.acqrel.fields.volatiles.ShortStringTest|tests.acqrel.fields.volatiles.StringBooleanTest|tests.acqrel.fields.volatiles.StringByteTest|tests.acqrel.fields.volatiles.StringCharTest|tests.acqrel.fields.volatiles.StringFloatTest|tests.acqrel.fields.volatiles.StringIntTest|tests.acqrel.fields.volatiles.StringShortTest|tests.acqrel.fields.volatiles.StringStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.varHandles.arrays.acqrel</testCaseName>
+	<!-- 57/82 org.openjdk.jcstress.tests.acqrel.varHandles.arrays.acqrel: classes 63/tests 126(ac/ar:126/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.varHandles.arrays.acqrel.BooleanBooleanTest|tests.acqrel.varHandles.arrays.acqrel.BooleanByteTest|tests.acqrel.varHandles.arrays.acqrel.BooleanCharTest|tests.acqrel.varHandles.arrays.acqrel.BooleanFloatTest|tests.acqrel.varHandles.arrays.acqrel.BooleanIntTest|tests.acqrel.varHandles.arrays.acqrel.BooleanShortTest|tests.acqrel.varHandles.arrays.acqrel.BooleanStringTest|tests.acqrel.varHandles.arrays.acqrel.ByteBooleanTest|tests.acqrel.varHandles.arrays.acqrel.ByteByteTest|tests.acqrel.varHandles.arrays.acqrel.ByteCharTest|tests.acqrel.varHandles.arrays.acqrel.ByteFloatTest|tests.acqrel.varHandles.arrays.acqrel.ByteIntTest|tests.acqrel.varHandles.arrays.acqrel.ByteShortTest|tests.acqrel.varHandles.arrays.acqrel.ByteStringTest|tests.acqrel.varHandles.arrays.acqrel.CharBooleanTest|tests.acqrel.varHandles.arrays.acqrel.CharByteTest|tests.acqrel.varHandles.arrays.acqrel.CharCharTest|tests.acqrel.varHandles.arrays.acqrel.CharFloatTest|tests.acqrel.varHandles.arrays.acqrel.CharIntTest|tests.acqrel.varHandles.arrays.acqrel.CharShortTest|tests.acqrel.varHandles.arrays.acqrel.CharStringTest|tests.acqrel.varHandles.arrays.acqrel.DoubleBooleanTest|tests.acqrel.varHandles.arrays.acqrel.DoubleByteTest|tests.acqrel.varHandles.arrays.acqrel.DoubleCharTest|tests.acqrel.varHandles.arrays.acqrel.DoubleFloatTest|tests.acqrel.varHandles.arrays.acqrel.DoubleIntTest|tests.acqrel.varHandles.arrays.acqrel.DoubleShortTest|tests.acqrel.varHandles.arrays.acqrel.DoubleStringTest|tests.acqrel.varHandles.arrays.acqrel.FloatBooleanTest|tests.acqrel.varHandles.arrays.acqrel.FloatByteTest|tests.acqrel.varHandles.arrays.acqrel.FloatCharTest|tests.acqrel.varHandles.arrays.acqrel.FloatFloatTest|tests.acqrel.varHandles.arrays.acqrel.FloatIntTest|tests.acqrel.varHandles.arrays.acqrel.FloatShortTest|tests.acqrel.varHandles.arrays.acqrel.FloatStringTest|tests.acqrel.varHandles.arrays.acqrel.IntBooleanTest|tests.acqrel.varHandles.arrays.acqrel.IntByteTest|tests.acqrel.varHandles.arrays.acqrel.IntCharTest|tests.acqrel.varHandles.arrays.acqrel.IntFloatTest|tests.acqrel.varHandles.arrays.acqrel.IntIntTest|tests.acqrel.varHandles.arrays.acqrel.IntShortTest|tests.acqrel.varHandles.arrays.acqrel.IntStringTest|tests.acqrel.varHandles.arrays.acqrel.LongBooleanTest|tests.acqrel.varHandles.arrays.acqrel.LongByteTest|tests.acqrel.varHandles.arrays.acqrel.LongCharTest|tests.acqrel.varHandles.arrays.acqrel.LongFloatTest|tests.acqrel.varHandles.arrays.acqrel.LongIntTest|tests.acqrel.varHandles.arrays.acqrel.LongShortTest|tests.acqrel.varHandles.arrays.acqrel.LongStringTest|tests.acqrel.varHandles.arrays.acqrel.ShortBooleanTest|tests.acqrel.varHandles.arrays.acqrel.ShortByteTest|tests.acqrel.varHandles.arrays.acqrel.ShortCharTest|tests.acqrel.varHandles.arrays.acqrel.ShortFloatTest|tests.acqrel.varHandles.arrays.acqrel.ShortIntTest|tests.acqrel.varHandles.arrays.acqrel.ShortShortTest|tests.acqrel.varHandles.arrays.acqrel.ShortStringTest|tests.acqrel.varHandles.arrays.acqrel.StringBooleanTest|tests.acqrel.varHandles.arrays.acqrel.StringByteTest|tests.acqrel.varHandles.arrays.acqrel.StringCharTest|tests.acqrel.varHandles.arrays.acqrel.StringFloatTest|tests.acqrel.varHandles.arrays.acqrel.StringIntTest|tests.acqrel.varHandles.arrays.acqrel.StringShortTest|tests.acqrel.varHandles.arrays.acqrel.StringStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.varHandles.arrays.volatiles</testCaseName>
+	<!-- 58/82 org.openjdk.jcstress.tests.acqrel.varHandles.arrays.volatiles: classes 63/tests 126(ac/ar:126/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.varHandles.arrays.volatiles.BooleanBooleanTest|tests.acqrel.varHandles.arrays.volatiles.BooleanByteTest|tests.acqrel.varHandles.arrays.volatiles.BooleanCharTest|tests.acqrel.varHandles.arrays.volatiles.BooleanFloatTest|tests.acqrel.varHandles.arrays.volatiles.BooleanIntTest|tests.acqrel.varHandles.arrays.volatiles.BooleanShortTest|tests.acqrel.varHandles.arrays.volatiles.BooleanStringTest|tests.acqrel.varHandles.arrays.volatiles.ByteBooleanTest|tests.acqrel.varHandles.arrays.volatiles.ByteByteTest|tests.acqrel.varHandles.arrays.volatiles.ByteCharTest|tests.acqrel.varHandles.arrays.volatiles.ByteFloatTest|tests.acqrel.varHandles.arrays.volatiles.ByteIntTest|tests.acqrel.varHandles.arrays.volatiles.ByteShortTest|tests.acqrel.varHandles.arrays.volatiles.ByteStringTest|tests.acqrel.varHandles.arrays.volatiles.CharBooleanTest|tests.acqrel.varHandles.arrays.volatiles.CharByteTest|tests.acqrel.varHandles.arrays.volatiles.CharCharTest|tests.acqrel.varHandles.arrays.volatiles.CharFloatTest|tests.acqrel.varHandles.arrays.volatiles.CharIntTest|tests.acqrel.varHandles.arrays.volatiles.CharShortTest|tests.acqrel.varHandles.arrays.volatiles.CharStringTest|tests.acqrel.varHandles.arrays.volatiles.DoubleBooleanTest|tests.acqrel.varHandles.arrays.volatiles.DoubleByteTest|tests.acqrel.varHandles.arrays.volatiles.DoubleCharTest|tests.acqrel.varHandles.arrays.volatiles.DoubleFloatTest|tests.acqrel.varHandles.arrays.volatiles.DoubleIntTest|tests.acqrel.varHandles.arrays.volatiles.DoubleShortTest|tests.acqrel.varHandles.arrays.volatiles.DoubleStringTest|tests.acqrel.varHandles.arrays.volatiles.FloatBooleanTest|tests.acqrel.varHandles.arrays.volatiles.FloatByteTest|tests.acqrel.varHandles.arrays.volatiles.FloatCharTest|tests.acqrel.varHandles.arrays.volatiles.FloatFloatTest|tests.acqrel.varHandles.arrays.volatiles.FloatIntTest|tests.acqrel.varHandles.arrays.volatiles.FloatShortTest|tests.acqrel.varHandles.arrays.volatiles.FloatStringTest|tests.acqrel.varHandles.arrays.volatiles.IntBooleanTest|tests.acqrel.varHandles.arrays.volatiles.IntByteTest|tests.acqrel.varHandles.arrays.volatiles.IntCharTest|tests.acqrel.varHandles.arrays.volatiles.IntFloatTest|tests.acqrel.varHandles.arrays.volatiles.IntIntTest|tests.acqrel.varHandles.arrays.volatiles.IntShortTest|tests.acqrel.varHandles.arrays.volatiles.IntStringTest|tests.acqrel.varHandles.arrays.volatiles.LongBooleanTest|tests.acqrel.varHandles.arrays.volatiles.LongByteTest|tests.acqrel.varHandles.arrays.volatiles.LongCharTest|tests.acqrel.varHandles.arrays.volatiles.LongFloatTest|tests.acqrel.varHandles.arrays.volatiles.LongIntTest|tests.acqrel.varHandles.arrays.volatiles.LongShortTest|tests.acqrel.varHandles.arrays.volatiles.LongStringTest|tests.acqrel.varHandles.arrays.volatiles.ShortBooleanTest|tests.acqrel.varHandles.arrays.volatiles.ShortByteTest|tests.acqrel.varHandles.arrays.volatiles.ShortCharTest|tests.acqrel.varHandles.arrays.volatiles.ShortFloatTest|tests.acqrel.varHandles.arrays.volatiles.ShortIntTest|tests.acqrel.varHandles.arrays.volatiles.ShortShortTest|tests.acqrel.varHandles.arrays.volatiles.ShortStringTest|tests.acqrel.varHandles.arrays.volatiles.StringBooleanTest|tests.acqrel.varHandles.arrays.volatiles.StringByteTest|tests.acqrel.varHandles.arrays.volatiles.StringCharTest|tests.acqrel.varHandles.arrays.volatiles.StringFloatTest|tests.acqrel.varHandles.arrays.volatiles.StringIntTest|tests.acqrel.varHandles.arrays.volatiles.StringShortTest|tests.acqrel.varHandles.arrays.volatiles.StringStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.varHandles.fields.acqrel</testCaseName>
+	<!-- 59/82 org.openjdk.jcstress.tests.acqrel.varHandles.fields.acqrel: classes 63/tests 126(ac/ar:126/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.varHandles.fields.acqrel.BooleanBooleanTest|tests.acqrel.varHandles.fields.acqrel.BooleanByteTest|tests.acqrel.varHandles.fields.acqrel.BooleanCharTest|tests.acqrel.varHandles.fields.acqrel.BooleanFloatTest|tests.acqrel.varHandles.fields.acqrel.BooleanIntTest|tests.acqrel.varHandles.fields.acqrel.BooleanShortTest|tests.acqrel.varHandles.fields.acqrel.BooleanStringTest|tests.acqrel.varHandles.fields.acqrel.ByteBooleanTest|tests.acqrel.varHandles.fields.acqrel.ByteByteTest|tests.acqrel.varHandles.fields.acqrel.ByteCharTest|tests.acqrel.varHandles.fields.acqrel.ByteFloatTest|tests.acqrel.varHandles.fields.acqrel.ByteIntTest|tests.acqrel.varHandles.fields.acqrel.ByteShortTest|tests.acqrel.varHandles.fields.acqrel.ByteStringTest|tests.acqrel.varHandles.fields.acqrel.CharBooleanTest|tests.acqrel.varHandles.fields.acqrel.CharByteTest|tests.acqrel.varHandles.fields.acqrel.CharCharTest|tests.acqrel.varHandles.fields.acqrel.CharFloatTest|tests.acqrel.varHandles.fields.acqrel.CharIntTest|tests.acqrel.varHandles.fields.acqrel.CharShortTest|tests.acqrel.varHandles.fields.acqrel.CharStringTest|tests.acqrel.varHandles.fields.acqrel.DoubleBooleanTest|tests.acqrel.varHandles.fields.acqrel.DoubleByteTest|tests.acqrel.varHandles.fields.acqrel.DoubleCharTest|tests.acqrel.varHandles.fields.acqrel.DoubleFloatTest|tests.acqrel.varHandles.fields.acqrel.DoubleIntTest|tests.acqrel.varHandles.fields.acqrel.DoubleShortTest|tests.acqrel.varHandles.fields.acqrel.DoubleStringTest|tests.acqrel.varHandles.fields.acqrel.FloatBooleanTest|tests.acqrel.varHandles.fields.acqrel.FloatByteTest|tests.acqrel.varHandles.fields.acqrel.FloatCharTest|tests.acqrel.varHandles.fields.acqrel.FloatFloatTest|tests.acqrel.varHandles.fields.acqrel.FloatIntTest|tests.acqrel.varHandles.fields.acqrel.FloatShortTest|tests.acqrel.varHandles.fields.acqrel.FloatStringTest|tests.acqrel.varHandles.fields.acqrel.IntBooleanTest|tests.acqrel.varHandles.fields.acqrel.IntByteTest|tests.acqrel.varHandles.fields.acqrel.IntCharTest|tests.acqrel.varHandles.fields.acqrel.IntFloatTest|tests.acqrel.varHandles.fields.acqrel.IntIntTest|tests.acqrel.varHandles.fields.acqrel.IntShortTest|tests.acqrel.varHandles.fields.acqrel.IntStringTest|tests.acqrel.varHandles.fields.acqrel.LongBooleanTest|tests.acqrel.varHandles.fields.acqrel.LongByteTest|tests.acqrel.varHandles.fields.acqrel.LongCharTest|tests.acqrel.varHandles.fields.acqrel.LongFloatTest|tests.acqrel.varHandles.fields.acqrel.LongIntTest|tests.acqrel.varHandles.fields.acqrel.LongShortTest|tests.acqrel.varHandles.fields.acqrel.LongStringTest|tests.acqrel.varHandles.fields.acqrel.ShortBooleanTest|tests.acqrel.varHandles.fields.acqrel.ShortByteTest|tests.acqrel.varHandles.fields.acqrel.ShortCharTest|tests.acqrel.varHandles.fields.acqrel.ShortFloatTest|tests.acqrel.varHandles.fields.acqrel.ShortIntTest|tests.acqrel.varHandles.fields.acqrel.ShortShortTest|tests.acqrel.varHandles.fields.acqrel.ShortStringTest|tests.acqrel.varHandles.fields.acqrel.StringBooleanTest|tests.acqrel.varHandles.fields.acqrel.StringByteTest|tests.acqrel.varHandles.fields.acqrel.StringCharTest|tests.acqrel.varHandles.fields.acqrel.StringFloatTest|tests.acqrel.varHandles.fields.acqrel.StringIntTest|tests.acqrel.varHandles.fields.acqrel.StringShortTest|tests.acqrel.varHandles.fields.acqrel.StringStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.varHandles.fields.volatiles</testCaseName>
+	<!-- 60/82 org.openjdk.jcstress.tests.acqrel.varHandles.fields.volatiles: classes 63/tests 126(ac/ar:126/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.varHandles.fields.volatiles.BooleanBooleanTest|tests.acqrel.varHandles.fields.volatiles.BooleanByteTest|tests.acqrel.varHandles.fields.volatiles.BooleanCharTest|tests.acqrel.varHandles.fields.volatiles.BooleanFloatTest|tests.acqrel.varHandles.fields.volatiles.BooleanIntTest|tests.acqrel.varHandles.fields.volatiles.BooleanShortTest|tests.acqrel.varHandles.fields.volatiles.BooleanStringTest|tests.acqrel.varHandles.fields.volatiles.ByteBooleanTest|tests.acqrel.varHandles.fields.volatiles.ByteByteTest|tests.acqrel.varHandles.fields.volatiles.ByteCharTest|tests.acqrel.varHandles.fields.volatiles.ByteFloatTest|tests.acqrel.varHandles.fields.volatiles.ByteIntTest|tests.acqrel.varHandles.fields.volatiles.ByteShortTest|tests.acqrel.varHandles.fields.volatiles.ByteStringTest|tests.acqrel.varHandles.fields.volatiles.CharBooleanTest|tests.acqrel.varHandles.fields.volatiles.CharByteTest|tests.acqrel.varHandles.fields.volatiles.CharCharTest|tests.acqrel.varHandles.fields.volatiles.CharFloatTest|tests.acqrel.varHandles.fields.volatiles.CharIntTest|tests.acqrel.varHandles.fields.volatiles.CharShortTest|tests.acqrel.varHandles.fields.volatiles.CharStringTest|tests.acqrel.varHandles.fields.volatiles.DoubleBooleanTest|tests.acqrel.varHandles.fields.volatiles.DoubleByteTest|tests.acqrel.varHandles.fields.volatiles.DoubleCharTest|tests.acqrel.varHandles.fields.volatiles.DoubleFloatTest|tests.acqrel.varHandles.fields.volatiles.DoubleIntTest|tests.acqrel.varHandles.fields.volatiles.DoubleShortTest|tests.acqrel.varHandles.fields.volatiles.DoubleStringTest|tests.acqrel.varHandles.fields.volatiles.FloatBooleanTest|tests.acqrel.varHandles.fields.volatiles.FloatByteTest|tests.acqrel.varHandles.fields.volatiles.FloatCharTest|tests.acqrel.varHandles.fields.volatiles.FloatFloatTest|tests.acqrel.varHandles.fields.volatiles.FloatIntTest|tests.acqrel.varHandles.fields.volatiles.FloatShortTest|tests.acqrel.varHandles.fields.volatiles.FloatStringTest|tests.acqrel.varHandles.fields.volatiles.IntBooleanTest|tests.acqrel.varHandles.fields.volatiles.IntByteTest|tests.acqrel.varHandles.fields.volatiles.IntCharTest|tests.acqrel.varHandles.fields.volatiles.IntFloatTest|tests.acqrel.varHandles.fields.volatiles.IntIntTest|tests.acqrel.varHandles.fields.volatiles.IntShortTest|tests.acqrel.varHandles.fields.volatiles.IntStringTest|tests.acqrel.varHandles.fields.volatiles.LongBooleanTest|tests.acqrel.varHandles.fields.volatiles.LongByteTest|tests.acqrel.varHandles.fields.volatiles.LongCharTest|tests.acqrel.varHandles.fields.volatiles.LongFloatTest|tests.acqrel.varHandles.fields.volatiles.LongIntTest|tests.acqrel.varHandles.fields.volatiles.LongShortTest|tests.acqrel.varHandles.fields.volatiles.LongStringTest|tests.acqrel.varHandles.fields.volatiles.ShortBooleanTest|tests.acqrel.varHandles.fields.volatiles.ShortByteTest|tests.acqrel.varHandles.fields.volatiles.ShortCharTest|tests.acqrel.varHandles.fields.volatiles.ShortFloatTest|tests.acqrel.varHandles.fields.volatiles.ShortIntTest|tests.acqrel.varHandles.fields.volatiles.ShortShortTest|tests.acqrel.varHandles.fields.volatiles.ShortStringTest|tests.acqrel.varHandles.fields.volatiles.StringBooleanTest|tests.acqrel.varHandles.fields.volatiles.StringByteTest|tests.acqrel.varHandles.fields.volatiles.StringCharTest|tests.acqrel.varHandles.fields.volatiles.StringFloatTest|tests.acqrel.varHandles.fields.volatiles.StringIntTest|tests.acqrel.varHandles.fields.volatiles.StringShortTest|tests.acqrel.varHandles.fields.volatiles.StringStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomicity</testCaseName>
+	<!-- 61/82 org.openjdk.jcstress.tests.atomicity: classes 63/tests 126(ac/ar:126/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomicity.buffers.ByteBufferAtomicityTests.ByteTest|tests.atomicity.buffers.ByteBufferAtomicityTests.CharTest|tests.atomicity.buffers.ByteBufferAtomicityTests.DoubleTest|tests.atomicity.buffers.ByteBufferAtomicityTests.FloatTest|tests.atomicity.buffers.ByteBufferAtomicityTests.IntTest|tests.atomicity.buffers.ByteBufferAtomicityTests.LongTest|tests.atomicity.buffers.ByteBufferAtomicityTests.ShortTest|tests.atomicity.buffers.ByteBufferViewsAtomicityTests.CharViewTest|tests.atomicity.buffers.ByteBufferViewsAtomicityTests.DoubleViewTest|tests.atomicity.buffers.ByteBufferViewsAtomicityTests.FloatViewTest|tests.atomicity.buffers.ByteBufferViewsAtomicityTests.IntViewTest|tests.atomicity.buffers.ByteBufferViewsAtomicityTests.LongViewTest|tests.atomicity.buffers.ByteBufferViewsAtomicityTests.ShortViewTest|tests.atomicity.buffers.CharBufferAtomicityTests.CharTest|tests.atomicity.buffers.DirectByteBufferAtomicityTests.ByteTest|tests.atomicity.buffers.DirectByteBufferAtomicityTests.CharTest|tests.atomicity.buffers.DirectByteBufferAtomicityTests.DoubleTest|tests.atomicity.buffers.DirectByteBufferAtomicityTests.FloatTest|tests.atomicity.buffers.DirectByteBufferAtomicityTests.IntTest|tests.atomicity.buffers.DirectByteBufferAtomicityTests.LongTest|tests.atomicity.buffers.DirectByteBufferAtomicityTests.ShortTest|tests.atomicity.buffers.DirectByteBufferViewsAtomicityTests.CharViewTest|tests.atomicity.buffers.DirectByteBufferViewsAtomicityTests.DoubleViewTest|tests.atomicity.buffers.DirectByteBufferViewsAtomicityTests.FloatViewTest|tests.atomicity.buffers.DirectByteBufferViewsAtomicityTests.IntViewTest|tests.atomicity.buffers.DirectByteBufferViewsAtomicityTests.LongViewTest|tests.atomicity.buffers.DirectByteBufferViewsAtomicityTests.ShortViewTest|tests.atomicity.buffers.DoubleBufferAtomicityTests.DoubleTest|tests.atomicity.buffers.FloatBufferAtomicityTests.FloatTest|tests.atomicity.buffers.IntBufferAtomicityTests.IntTest|tests.atomicity.buffers.LongBufferAtomicityTests.LongTest|tests.atomicity.buffers.ShortBufferAtomicityTests.ShortTest|tests.atomicity.crosscache.ByteBufferIntAtomicityTest|tests.atomicity.crosscache.DirectByteBufferIntAtomicityTest|tests.atomicity.crosscache.UnsafeIntAtomicityTest|tests.atomicity.primitives.perbyte.ByteAtomicityTest|tests.atomicity.primitives.perbyte.CharAtomicityTest|tests.atomicity.primitives.perbyte.DoubleAtomicityTest|tests.atomicity.primitives.perbyte.FloatAtomicityTest|tests.atomicity.primitives.perbyte.IntAtomicityTest|tests.atomicity.primitives.perbyte.LongAtomicityTest|tests.atomicity.primitives.perbyte.ShortAtomicityTest|tests.atomicity.primitives.perbyte.VolatileByteAtomicityTest|tests.atomicity.primitives.perbyte.VolatileCharAtomicityTest|tests.atomicity.primitives.perbyte.VolatileDoubleAtomicityTest|tests.atomicity.primitives.perbyte.VolatileFloatAtomicityTest|tests.atomicity.primitives.perbyte.VolatileIntAtomicityTest|tests.atomicity.primitives.perbyte.VolatileLongAtomicityTest|tests.atomicity.primitives.perbyte.VolatileShortAtomicityTest|tests.atomicity.primitives.reflect.ByteAtomicityTest|tests.atomicity.primitives.reflect.CharAtomicityTest|tests.atomicity.primitives.reflect.DoubleAtomicityTest|tests.atomicity.primitives.reflect.FloatAtomicityTest|tests.atomicity.primitives.reflect.IntAtomicityTest|tests.atomicity.primitives.reflect.LongAtomicityTest|tests.atomicity.primitives.reflect.ShortAtomicityTest|tests.atomicity.primitives.reflect.VolatileByteAtomicityTest|tests.atomicity.primitives.reflect.VolatileCharAtomicityTest|tests.atomicity.primitives.reflect.VolatileDoubleAtomicityTest|tests.atomicity.primitives.reflect.VolatileFloatAtomicityTest|tests.atomicity.primitives.reflect.VolatileIntAtomicityTest|tests.atomicity.primitives.reflect.VolatileLongAtomicityTest|tests.atomicity.primitives.reflect.VolatileShortAtomicityTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomicity.varHandles.arrays</testCaseName>
+	<!-- 62/82 org.openjdk.jcstress.tests.atomicity.varHandles.arrays: classes 47/tests 141(ac/ar:94/47)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeAcquireBoolean|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeAcquireByte|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeAcquireChar|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeAcquireDouble|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeAcquireFloat|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeAcquireInt|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeAcquireLong|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeAcquireShort|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeAcquireString|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeBoolean|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeByte|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeChar|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeDouble|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeFloat|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeInt|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeLong|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeReleaseBoolean|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeReleaseByte|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeReleaseChar|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeReleaseDouble|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeReleaseFloat|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeReleaseInt|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeReleaseLong|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeReleaseShort|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeReleaseString|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeShort|tests.atomicity.varHandles.arrays.CAETest.CompareAndExchangeString|tests.atomicity.varHandles.arrays.CASTest.CompareAndSetBoolean|tests.atomicity.varHandles.arrays.CASTest.CompareAndSetByte|tests.atomicity.varHandles.arrays.CASTest.CompareAndSetChar|tests.atomicity.varHandles.arrays.CASTest.CompareAndSetDouble|tests.atomicity.varHandles.arrays.CASTest.CompareAndSetFloat|tests.atomicity.varHandles.arrays.CASTest.CompareAndSetInt|tests.atomicity.varHandles.arrays.CASTest.CompareAndSetLong|tests.atomicity.varHandles.arrays.CASTest.CompareAndSetShort|tests.atomicity.varHandles.arrays.CASTest.CompareAndSetString|tests.atomicity.varHandles.arrays.GetAndAddTest.GetAndAddInt|tests.atomicity.varHandles.arrays.GetAndAddTest.GetAndAddLong|tests.atomicity.varHandles.arrays.GetAndSetTest.GetAndSetBoolean|tests.atomicity.varHandles.arrays.GetAndSetTest.GetAndSetByte|tests.atomicity.varHandles.arrays.GetAndSetTest.GetAndSetChar|tests.atomicity.varHandles.arrays.GetAndSetTest.GetAndSetDouble|tests.atomicity.varHandles.arrays.GetAndSetTest.GetAndSetFloat|tests.atomicity.varHandles.arrays.GetAndSetTest.GetAndSetInt|tests.atomicity.varHandles.arrays.GetAndSetTest.GetAndSetLong|tests.atomicity.varHandles.arrays.GetAndSetTest.GetAndSetShort|tests.atomicity.varHandles.arrays.GetAndSetTest.GetAndSetString"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomicity.varHandles.fields</testCaseName>
+	<!-- 63/82 org.openjdk.jcstress.tests.atomicity.varHandles.fields: classes 47/tests 141(ac/ar:94/47)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeAcquireBoolean|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeAcquireByte|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeAcquireChar|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeAcquireDouble|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeAcquireFloat|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeAcquireInt|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeAcquireLong|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeAcquireShort|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeAcquireString|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeBoolean|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeByte|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeChar|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeDouble|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeFloat|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeInt|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeLong|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeReleaseBoolean|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeReleaseByte|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeReleaseChar|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeReleaseDouble|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeReleaseFloat|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeReleaseInt|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeReleaseLong|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeReleaseShort|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeReleaseString|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeShort|tests.atomicity.varHandles.fields.CAETest.CompareAndExchangeString|tests.atomicity.varHandles.fields.CASTest.CompareAndSetBoolean|tests.atomicity.varHandles.fields.CASTest.CompareAndSetByte|tests.atomicity.varHandles.fields.CASTest.CompareAndSetChar|tests.atomicity.varHandles.fields.CASTest.CompareAndSetDouble|tests.atomicity.varHandles.fields.CASTest.CompareAndSetFloat|tests.atomicity.varHandles.fields.CASTest.CompareAndSetInt|tests.atomicity.varHandles.fields.CASTest.CompareAndSetLong|tests.atomicity.varHandles.fields.CASTest.CompareAndSetShort|tests.atomicity.varHandles.fields.CASTest.CompareAndSetString|tests.atomicity.varHandles.fields.GetAndAddTest.GetAndAddInt|tests.atomicity.varHandles.fields.GetAndAddTest.GetAndAddLong|tests.atomicity.varHandles.fields.GetAndSetTest.GetAndSetBoolean|tests.atomicity.varHandles.fields.GetAndSetTest.GetAndSetByte|tests.atomicity.varHandles.fields.GetAndSetTest.GetAndSetChar|tests.atomicity.varHandles.fields.GetAndSetTest.GetAndSetDouble|tests.atomicity.varHandles.fields.GetAndSetTest.GetAndSetFloat|tests.atomicity.varHandles.fields.GetAndSetTest.GetAndSetInt|tests.atomicity.varHandles.fields.GetAndSetTest.GetAndSetLong|tests.atomicity.varHandles.fields.GetAndSetTest.GetAndSetShort|tests.atomicity.varHandles.fields.GetAndSetTest.GetAndSetString"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.memeffects.basic</testCaseName>
+	<!-- 64/82 org.openjdk.jcstress.tests.memeffects.basic: classes 78/tests 156(ac/ar:156/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_compareAndSet_byte|tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_compareAndSet_double|tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_compareAndSet_float|tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_compareAndSet_int|tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_compareAndSet_long|tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_compareAndSet_short|tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_set_byte|tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_set_double|tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_set_float|tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_set_int|tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_set_long|tests.memeffects.basic.atomic.AtomicBoolean.atomic_compareAndSet_set_short|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_compareAndSet_byte|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_compareAndSet_double|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_compareAndSet_float|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_compareAndSet_int|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_compareAndSet_long|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_compareAndSet_short|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_set_byte|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_set_double|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_set_float|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_set_int|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_set_long|tests.memeffects.basic.atomic.AtomicBoolean.atomic_get_set_short|tests.memeffects.basic.lock.lock_byte|tests.memeffects.basic.lock.lock_double|tests.memeffects.basic.lock.lock_float|tests.memeffects.basic.lock.lock_int|tests.memeffects.basic.lock.lock_long|tests.memeffects.basic.lock.lock_short|tests.memeffects.basic.volatiles.volatile_boolean_byte|tests.memeffects.basic.volatiles.volatile_boolean_double|tests.memeffects.basic.volatiles.volatile_boolean_float|tests.memeffects.basic.volatiles.volatile_boolean_int|tests.memeffects.basic.volatiles.volatile_boolean_long|tests.memeffects.basic.volatiles.volatile_boolean_short|tests.memeffects.basic.volatiles.volatile_byte_byte|tests.memeffects.basic.volatiles.volatile_byte_double|tests.memeffects.basic.volatiles.volatile_byte_float|tests.memeffects.basic.volatiles.volatile_byte_int|tests.memeffects.basic.volatiles.volatile_byte_long|tests.memeffects.basic.volatiles.volatile_byte_short|tests.memeffects.basic.volatiles.volatile_char_byte|tests.memeffects.basic.volatiles.volatile_char_double|tests.memeffects.basic.volatiles.volatile_char_float|tests.memeffects.basic.volatiles.volatile_char_int|tests.memeffects.basic.volatiles.volatile_char_long|tests.memeffects.basic.volatiles.volatile_char_short|tests.memeffects.basic.volatiles.volatile_double_byte|tests.memeffects.basic.volatiles.volatile_double_double|tests.memeffects.basic.volatiles.volatile_double_float|tests.memeffects.basic.volatiles.volatile_double_int|tests.memeffects.basic.volatiles.volatile_double_long|tests.memeffects.basic.volatiles.volatile_double_short|tests.memeffects.basic.volatiles.volatile_float_byte|tests.memeffects.basic.volatiles.volatile_float_double|tests.memeffects.basic.volatiles.volatile_float_float|tests.memeffects.basic.volatiles.volatile_float_int|tests.memeffects.basic.volatiles.volatile_float_long|tests.memeffects.basic.volatiles.volatile_float_short|tests.memeffects.basic.volatiles.volatile_int_byte|tests.memeffects.basic.volatiles.volatile_int_double|tests.memeffects.basic.volatiles.volatile_int_float|tests.memeffects.basic.volatiles.volatile_int_int|tests.memeffects.basic.volatiles.volatile_int_long|tests.memeffects.basic.volatiles.volatile_int_short|tests.memeffects.basic.volatiles.volatile_long_byte|tests.memeffects.basic.volatiles.volatile_long_double|tests.memeffects.basic.volatiles.volatile_long_float|tests.memeffects.basic.volatiles.volatile_long_int|tests.memeffects.basic.volatiles.volatile_long_long|tests.memeffects.basic.volatiles.volatile_long_short|tests.memeffects.basic.volatiles.volatile_short_byte|tests.memeffects.basic.volatiles.volatile_short_double|tests.memeffects.basic.volatiles.volatile_short_float|tests.memeffects.basic.volatiles.volatile_short_int|tests.memeffects.basic.volatiles.volatile_short_long|tests.memeffects.basic.volatiles.volatile_short_short"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.locks.mutex</testCaseName>
+	<!-- 65/82 org.openjdk.jcstress.tests.locks.mutex: classes 80/tests 160(ac/ar:160/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.locks.mutex.ReentrantLockMutexTests.I_F.LI_L|tests.locks.mutex.ReentrantLockMutexTests.I_F.LI_LI|tests.locks.mutex.ReentrantLockMutexTests.I_F.LI_TL|tests.locks.mutex.ReentrantLockMutexTests.I_F.LI_TLt|tests.locks.mutex.ReentrantLockMutexTests.I_F.L_L|tests.locks.mutex.ReentrantLockMutexTests.I_F.L_TL|tests.locks.mutex.ReentrantLockMutexTests.I_F.L_TLt|tests.locks.mutex.ReentrantLockMutexTests.I_F.TL_TL|tests.locks.mutex.ReentrantLockMutexTests.I_F.TL_TLt|tests.locks.mutex.ReentrantLockMutexTests.I_F.TLt_TLt|tests.locks.mutex.ReentrantLockMutexTests.I_N.LI_L|tests.locks.mutex.ReentrantLockMutexTests.I_N.LI_LI|tests.locks.mutex.ReentrantLockMutexTests.I_N.LI_TL|tests.locks.mutex.ReentrantLockMutexTests.I_N.LI_TLt|tests.locks.mutex.ReentrantLockMutexTests.I_N.L_L|tests.locks.mutex.ReentrantLockMutexTests.I_N.L_TL|tests.locks.mutex.ReentrantLockMutexTests.I_N.L_TLt|tests.locks.mutex.ReentrantLockMutexTests.I_N.TL_TL|tests.locks.mutex.ReentrantLockMutexTests.I_N.TL_TLt|tests.locks.mutex.ReentrantLockMutexTests.I_N.TLt_TLt|tests.locks.mutex.ReentrantLockMutexTests.S_F.LI_L|tests.locks.mutex.ReentrantLockMutexTests.S_F.LI_LI|tests.locks.mutex.ReentrantLockMutexTests.S_F.LI_TL|tests.locks.mutex.ReentrantLockMutexTests.S_F.LI_TLt|tests.locks.mutex.ReentrantLockMutexTests.S_F.L_L|tests.locks.mutex.ReentrantLockMutexTests.S_F.L_TL|tests.locks.mutex.ReentrantLockMutexTests.S_F.L_TLt|tests.locks.mutex.ReentrantLockMutexTests.S_F.TL_TL|tests.locks.mutex.ReentrantLockMutexTests.S_F.TL_TLt|tests.locks.mutex.ReentrantLockMutexTests.S_F.TLt_TLt|tests.locks.mutex.ReentrantLockMutexTests.S_N.LI_L|tests.locks.mutex.ReentrantLockMutexTests.S_N.LI_LI|tests.locks.mutex.ReentrantLockMutexTests.S_N.LI_TL|tests.locks.mutex.ReentrantLockMutexTests.S_N.LI_TLt|tests.locks.mutex.ReentrantLockMutexTests.S_N.L_L|tests.locks.mutex.ReentrantLockMutexTests.S_N.L_TL|tests.locks.mutex.ReentrantLockMutexTests.S_N.L_TLt|tests.locks.mutex.ReentrantLockMutexTests.S_N.TL_TL|tests.locks.mutex.ReentrantLockMutexTests.S_N.TL_TLt|tests.locks.mutex.ReentrantLockMutexTests.S_N.TLt_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.I_F.LI_L|tests.locks.mutex.ReentrantRWLockMutexTests.I_F.LI_LI|tests.locks.mutex.ReentrantRWLockMutexTests.I_F.LI_TL|tests.locks.mutex.ReentrantRWLockMutexTests.I_F.LI_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.I_F.L_L|tests.locks.mutex.ReentrantRWLockMutexTests.I_F.L_TL|tests.locks.mutex.ReentrantRWLockMutexTests.I_F.L_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.I_F.TL_TL|tests.locks.mutex.ReentrantRWLockMutexTests.I_F.TL_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.I_F.TLt_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.I_N.LI_L|tests.locks.mutex.ReentrantRWLockMutexTests.I_N.LI_LI|tests.locks.mutex.ReentrantRWLockMutexTests.I_N.LI_TL|tests.locks.mutex.ReentrantRWLockMutexTests.I_N.LI_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.I_N.L_L|tests.locks.mutex.ReentrantRWLockMutexTests.I_N.L_TL|tests.locks.mutex.ReentrantRWLockMutexTests.I_N.L_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.I_N.TL_TL|tests.locks.mutex.ReentrantRWLockMutexTests.I_N.TL_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.I_N.TLt_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.S_F.LI_L|tests.locks.mutex.ReentrantRWLockMutexTests.S_F.LI_LI|tests.locks.mutex.ReentrantRWLockMutexTests.S_F.LI_TL|tests.locks.mutex.ReentrantRWLockMutexTests.S_F.LI_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.S_F.L_L|tests.locks.mutex.ReentrantRWLockMutexTests.S_F.L_TL|tests.locks.mutex.ReentrantRWLockMutexTests.S_F.L_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.S_F.TL_TL|tests.locks.mutex.ReentrantRWLockMutexTests.S_F.TL_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.S_F.TLt_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.S_N.LI_L|tests.locks.mutex.ReentrantRWLockMutexTests.S_N.LI_LI|tests.locks.mutex.ReentrantRWLockMutexTests.S_N.LI_TL|tests.locks.mutex.ReentrantRWLockMutexTests.S_N.LI_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.S_N.L_L|tests.locks.mutex.ReentrantRWLockMutexTests.S_N.L_TL|tests.locks.mutex.ReentrantRWLockMutexTests.S_N.L_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.S_N.TL_TL|tests.locks.mutex.ReentrantRWLockMutexTests.S_N.TL_TLt|tests.locks.mutex.ReentrantRWLockMutexTests.S_N.TLt_TLt"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomicity.varHandles.byteArray</testCaseName>
+	<!-- 66/82 org.openjdk.jcstress.tests.atomicity.varHandles.byteArray: classes 54/tests 162(ac/ar:108/54)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomicity.varHandles.byteArray.big.CAETest.CompareAndExchangeAcquireFloat|tests.atomicity.varHandles.byteArray.big.CAETest.CompareAndExchangeAcquireInt|tests.atomicity.varHandles.byteArray.big.CAETest.CompareAndExchangeFloat|tests.atomicity.varHandles.byteArray.big.CAETest.CompareAndExchangeInt|tests.atomicity.varHandles.byteArray.big.CAETest.CompareAndExchangeReleaseFloat|tests.atomicity.varHandles.byteArray.big.CAETest.CompareAndExchangeReleaseInt|tests.atomicity.varHandles.byteArray.big.CASTest.CompareAndSetFloat|tests.atomicity.varHandles.byteArray.big.CASTest.CompareAndSetInt|tests.atomicity.varHandles.byteArray.big.GetAndAddTest.GetAndAddInt|tests.atomicity.varHandles.byteArray.big.GetAndSetTest.GetAndSetFloat|tests.atomicity.varHandles.byteArray.big.GetAndSetTest.GetAndSetInt|tests.atomicity.varHandles.byteArray.big.WeakCASContendStrongTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteArray.big.WeakCASContendStrongTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteArray.big.WeakCASContendStrongTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteArray.big.WeakCASContendStrongTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteArray.big.WeakCASContendStrongTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteArray.big.WeakCASContendStrongTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteArray.big.WeakCASContendStrongTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteArray.big.WeakCASContendStrongTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.byteArray.big.WeakCASTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteArray.big.WeakCASTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteArray.big.WeakCASTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteArray.big.WeakCASTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteArray.big.WeakCASTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteArray.big.WeakCASTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteArray.big.WeakCASTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteArray.big.WeakCASTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.byteArray.little.CAETest.CompareAndExchangeAcquireFloat|tests.atomicity.varHandles.byteArray.little.CAETest.CompareAndExchangeAcquireInt|tests.atomicity.varHandles.byteArray.little.CAETest.CompareAndExchangeFloat|tests.atomicity.varHandles.byteArray.little.CAETest.CompareAndExchangeInt|tests.atomicity.varHandles.byteArray.little.CAETest.CompareAndExchangeReleaseFloat|tests.atomicity.varHandles.byteArray.little.CAETest.CompareAndExchangeReleaseInt|tests.atomicity.varHandles.byteArray.little.CASTest.CompareAndSetFloat|tests.atomicity.varHandles.byteArray.little.CASTest.CompareAndSetInt|tests.atomicity.varHandles.byteArray.little.GetAndAddTest.GetAndAddInt|tests.atomicity.varHandles.byteArray.little.GetAndSetTest.GetAndSetFloat|tests.atomicity.varHandles.byteArray.little.GetAndSetTest.GetAndSetInt|tests.atomicity.varHandles.byteArray.little.WeakCASContendStrongTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteArray.little.WeakCASContendStrongTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteArray.little.WeakCASContendStrongTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteArray.little.WeakCASContendStrongTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteArray.little.WeakCASContendStrongTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteArray.little.WeakCASContendStrongTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteArray.little.WeakCASContendStrongTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteArray.little.WeakCASContendStrongTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.byteArray.little.WeakCASTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteArray.little.WeakCASTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteArray.little.WeakCASTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteArray.little.WeakCASTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteArray.little.WeakCASTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteArray.little.WeakCASTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteArray.little.WeakCASTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteArray.little.WeakCASTest.WeakCompareAndSetReleaseInt"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomicity.varHandles.byteBuffer.direct</testCaseName>
+	<!-- 67/82 org.openjdk.jcstress.tests.atomicity.varHandles.byteBuffer.direct: classes 54/tests 162(ac/ar:108/54)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomicity.varHandles.byteBuffer.direct.big.CAETest.CompareAndExchangeAcquireFloat|tests.atomicity.varHandles.byteBuffer.direct.big.CAETest.CompareAndExchangeAcquireInt|tests.atomicity.varHandles.byteBuffer.direct.big.CAETest.CompareAndExchangeFloat|tests.atomicity.varHandles.byteBuffer.direct.big.CAETest.CompareAndExchangeInt|tests.atomicity.varHandles.byteBuffer.direct.big.CAETest.CompareAndExchangeReleaseFloat|tests.atomicity.varHandles.byteBuffer.direct.big.CAETest.CompareAndExchangeReleaseInt|tests.atomicity.varHandles.byteBuffer.direct.big.CASTest.CompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.direct.big.CASTest.CompareAndSetInt|tests.atomicity.varHandles.byteBuffer.direct.big.GetAndAddTest.GetAndAddInt|tests.atomicity.varHandles.byteBuffer.direct.big.GetAndSetTest.GetAndSetFloat|tests.atomicity.varHandles.byteBuffer.direct.big.GetAndSetTest.GetAndSetInt|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASContendStrongTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASContendStrongTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASContendStrongTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASContendStrongTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASContendStrongTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASContendStrongTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASContendStrongTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASContendStrongTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteBuffer.direct.big.WeakCASTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.byteBuffer.direct.little.CAETest.CompareAndExchangeAcquireFloat|tests.atomicity.varHandles.byteBuffer.direct.little.CAETest.CompareAndExchangeAcquireInt|tests.atomicity.varHandles.byteBuffer.direct.little.CAETest.CompareAndExchangeFloat|tests.atomicity.varHandles.byteBuffer.direct.little.CAETest.CompareAndExchangeInt|tests.atomicity.varHandles.byteBuffer.direct.little.CAETest.CompareAndExchangeReleaseFloat|tests.atomicity.varHandles.byteBuffer.direct.little.CAETest.CompareAndExchangeReleaseInt|tests.atomicity.varHandles.byteBuffer.direct.little.CASTest.CompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.direct.little.CASTest.CompareAndSetInt|tests.atomicity.varHandles.byteBuffer.direct.little.GetAndAddTest.GetAndAddInt|tests.atomicity.varHandles.byteBuffer.direct.little.GetAndSetTest.GetAndSetFloat|tests.atomicity.varHandles.byteBuffer.direct.little.GetAndSetTest.GetAndSetInt|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASContendStrongTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASContendStrongTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASContendStrongTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASContendStrongTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASContendStrongTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASContendStrongTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASContendStrongTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASContendStrongTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteBuffer.direct.little.WeakCASTest.WeakCompareAndSetReleaseInt"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.atomicity.varHandles.byteBuffer.heap</testCaseName>
+	<!-- 68/82 org.openjdk.jcstress.tests.atomicity.varHandles.byteBuffer.heap: classes 54/tests 162(ac/ar:108/54)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.atomicity.varHandles.byteBuffer.heap.big.CAETest.CompareAndExchangeAcquireFloat|tests.atomicity.varHandles.byteBuffer.heap.big.CAETest.CompareAndExchangeAcquireInt|tests.atomicity.varHandles.byteBuffer.heap.big.CAETest.CompareAndExchangeFloat|tests.atomicity.varHandles.byteBuffer.heap.big.CAETest.CompareAndExchangeInt|tests.atomicity.varHandles.byteBuffer.heap.big.CAETest.CompareAndExchangeReleaseFloat|tests.atomicity.varHandles.byteBuffer.heap.big.CAETest.CompareAndExchangeReleaseInt|tests.atomicity.varHandles.byteBuffer.heap.big.CASTest.CompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.heap.big.CASTest.CompareAndSetInt|tests.atomicity.varHandles.byteBuffer.heap.big.GetAndAddTest.GetAndAddInt|tests.atomicity.varHandles.byteBuffer.heap.big.GetAndSetTest.GetAndSetFloat|tests.atomicity.varHandles.byteBuffer.heap.big.GetAndSetTest.GetAndSetInt|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASContendStrongTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASContendStrongTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASContendStrongTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASContendStrongTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASContendStrongTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASContendStrongTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASContendStrongTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASContendStrongTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteBuffer.heap.big.WeakCASTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.byteBuffer.heap.little.CAETest.CompareAndExchangeAcquireFloat|tests.atomicity.varHandles.byteBuffer.heap.little.CAETest.CompareAndExchangeAcquireInt|tests.atomicity.varHandles.byteBuffer.heap.little.CAETest.CompareAndExchangeFloat|tests.atomicity.varHandles.byteBuffer.heap.little.CAETest.CompareAndExchangeInt|tests.atomicity.varHandles.byteBuffer.heap.little.CAETest.CompareAndExchangeReleaseFloat|tests.atomicity.varHandles.byteBuffer.heap.little.CAETest.CompareAndExchangeReleaseInt|tests.atomicity.varHandles.byteBuffer.heap.little.CASTest.CompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.heap.little.CASTest.CompareAndSetInt|tests.atomicity.varHandles.byteBuffer.heap.little.GetAndAddTest.GetAndAddInt|tests.atomicity.varHandles.byteBuffer.heap.little.GetAndSetTest.GetAndSetFloat|tests.atomicity.varHandles.byteBuffer.heap.little.GetAndSetTest.GetAndSetInt|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASContendStrongTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASContendStrongTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASContendStrongTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASContendStrongTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASContendStrongTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASContendStrongTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASContendStrongTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASContendStrongTest.WeakCompareAndSetReleaseInt|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASTest.WeakCompareAndSetAcquireFloat|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASTest.WeakCompareAndSetAcquireInt|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASTest.WeakCompareAndSetFloat|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASTest.WeakCompareAndSetInt|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASTest.WeakCompareAndSetPlainFloat|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASTest.WeakCompareAndSetPlainInt|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASTest.WeakCompareAndSetReleaseFloat|tests.atomicity.varHandles.byteBuffer.heap.little.WeakCASTest.WeakCompareAndSetReleaseInt"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.varHandles.byteArray.big</testCaseName>
+	<!-- 69/82 org.openjdk.jcstress.tests.acqrel.varHandles.byteArray.big: classes 84/tests 168(ac/ar:168/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.varHandles.byteArray.big.acqrel.CharBooleanTest|tests.acqrel.varHandles.byteArray.big.acqrel.CharByteTest|tests.acqrel.varHandles.byteArray.big.acqrel.CharCharTest|tests.acqrel.varHandles.byteArray.big.acqrel.CharFloatTest|tests.acqrel.varHandles.byteArray.big.acqrel.CharIntTest|tests.acqrel.varHandles.byteArray.big.acqrel.CharShortTest|tests.acqrel.varHandles.byteArray.big.acqrel.CharStringTest|tests.acqrel.varHandles.byteArray.big.acqrel.DoubleBooleanTest|tests.acqrel.varHandles.byteArray.big.acqrel.DoubleByteTest|tests.acqrel.varHandles.byteArray.big.acqrel.DoubleCharTest|tests.acqrel.varHandles.byteArray.big.acqrel.DoubleFloatTest|tests.acqrel.varHandles.byteArray.big.acqrel.DoubleIntTest|tests.acqrel.varHandles.byteArray.big.acqrel.DoubleShortTest|tests.acqrel.varHandles.byteArray.big.acqrel.DoubleStringTest|tests.acqrel.varHandles.byteArray.big.acqrel.FloatBooleanTest|tests.acqrel.varHandles.byteArray.big.acqrel.FloatByteTest|tests.acqrel.varHandles.byteArray.big.acqrel.FloatCharTest|tests.acqrel.varHandles.byteArray.big.acqrel.FloatFloatTest|tests.acqrel.varHandles.byteArray.big.acqrel.FloatIntTest|tests.acqrel.varHandles.byteArray.big.acqrel.FloatShortTest|tests.acqrel.varHandles.byteArray.big.acqrel.FloatStringTest|tests.acqrel.varHandles.byteArray.big.acqrel.IntBooleanTest|tests.acqrel.varHandles.byteArray.big.acqrel.IntByteTest|tests.acqrel.varHandles.byteArray.big.acqrel.IntCharTest|tests.acqrel.varHandles.byteArray.big.acqrel.IntFloatTest|tests.acqrel.varHandles.byteArray.big.acqrel.IntIntTest|tests.acqrel.varHandles.byteArray.big.acqrel.IntShortTest|tests.acqrel.varHandles.byteArray.big.acqrel.IntStringTest|tests.acqrel.varHandles.byteArray.big.acqrel.LongBooleanTest|tests.acqrel.varHandles.byteArray.big.acqrel.LongByteTest|tests.acqrel.varHandles.byteArray.big.acqrel.LongCharTest|tests.acqrel.varHandles.byteArray.big.acqrel.LongFloatTest|tests.acqrel.varHandles.byteArray.big.acqrel.LongIntTest|tests.acqrel.varHandles.byteArray.big.acqrel.LongShortTest|tests.acqrel.varHandles.byteArray.big.acqrel.LongStringTest|tests.acqrel.varHandles.byteArray.big.acqrel.ShortBooleanTest|tests.acqrel.varHandles.byteArray.big.acqrel.ShortByteTest|tests.acqrel.varHandles.byteArray.big.acqrel.ShortCharTest|tests.acqrel.varHandles.byteArray.big.acqrel.ShortFloatTest|tests.acqrel.varHandles.byteArray.big.acqrel.ShortIntTest|tests.acqrel.varHandles.byteArray.big.acqrel.ShortShortTest|tests.acqrel.varHandles.byteArray.big.acqrel.ShortStringTest|tests.acqrel.varHandles.byteArray.big.volatiles.CharBooleanTest|tests.acqrel.varHandles.byteArray.big.volatiles.CharByteTest|tests.acqrel.varHandles.byteArray.big.volatiles.CharCharTest|tests.acqrel.varHandles.byteArray.big.volatiles.CharFloatTest|tests.acqrel.varHandles.byteArray.big.volatiles.CharIntTest|tests.acqrel.varHandles.byteArray.big.volatiles.CharShortTest|tests.acqrel.varHandles.byteArray.big.volatiles.CharStringTest|tests.acqrel.varHandles.byteArray.big.volatiles.DoubleBooleanTest|tests.acqrel.varHandles.byteArray.big.volatiles.DoubleByteTest|tests.acqrel.varHandles.byteArray.big.volatiles.DoubleCharTest|tests.acqrel.varHandles.byteArray.big.volatiles.DoubleFloatTest|tests.acqrel.varHandles.byteArray.big.volatiles.DoubleIntTest|tests.acqrel.varHandles.byteArray.big.volatiles.DoubleShortTest|tests.acqrel.varHandles.byteArray.big.volatiles.DoubleStringTest|tests.acqrel.varHandles.byteArray.big.volatiles.FloatBooleanTest|tests.acqrel.varHandles.byteArray.big.volatiles.FloatByteTest|tests.acqrel.varHandles.byteArray.big.volatiles.FloatCharTest|tests.acqrel.varHandles.byteArray.big.volatiles.FloatFloatTest|tests.acqrel.varHandles.byteArray.big.volatiles.FloatIntTest|tests.acqrel.varHandles.byteArray.big.volatiles.FloatShortTest|tests.acqrel.varHandles.byteArray.big.volatiles.FloatStringTest|tests.acqrel.varHandles.byteArray.big.volatiles.IntBooleanTest|tests.acqrel.varHandles.byteArray.big.volatiles.IntByteTest|tests.acqrel.varHandles.byteArray.big.volatiles.IntCharTest|tests.acqrel.varHandles.byteArray.big.volatiles.IntFloatTest|tests.acqrel.varHandles.byteArray.big.volatiles.IntIntTest|tests.acqrel.varHandles.byteArray.big.volatiles.IntShortTest|tests.acqrel.varHandles.byteArray.big.volatiles.IntStringTest|tests.acqrel.varHandles.byteArray.big.volatiles.LongBooleanTest|tests.acqrel.varHandles.byteArray.big.volatiles.LongByteTest|tests.acqrel.varHandles.byteArray.big.volatiles.LongCharTest|tests.acqrel.varHandles.byteArray.big.volatiles.LongFloatTest|tests.acqrel.varHandles.byteArray.big.volatiles.LongIntTest|tests.acqrel.varHandles.byteArray.big.volatiles.LongShortTest|tests.acqrel.varHandles.byteArray.big.volatiles.LongStringTest|tests.acqrel.varHandles.byteArray.big.volatiles.ShortBooleanTest|tests.acqrel.varHandles.byteArray.big.volatiles.ShortByteTest|tests.acqrel.varHandles.byteArray.big.volatiles.ShortCharTest|tests.acqrel.varHandles.byteArray.big.volatiles.ShortFloatTest|tests.acqrel.varHandles.byteArray.big.volatiles.ShortIntTest|tests.acqrel.varHandles.byteArray.big.volatiles.ShortShortTest|tests.acqrel.varHandles.byteArray.big.volatiles.ShortStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.varHandles.byteArray.little</testCaseName>
+	<!-- 70/82 org.openjdk.jcstress.tests.acqrel.varHandles.byteArray.little: classes 84/tests 168(ac/ar:168/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.varHandles.byteArray.little.acqrel.CharBooleanTest|tests.acqrel.varHandles.byteArray.little.acqrel.CharByteTest|tests.acqrel.varHandles.byteArray.little.acqrel.CharCharTest|tests.acqrel.varHandles.byteArray.little.acqrel.CharFloatTest|tests.acqrel.varHandles.byteArray.little.acqrel.CharIntTest|tests.acqrel.varHandles.byteArray.little.acqrel.CharShortTest|tests.acqrel.varHandles.byteArray.little.acqrel.CharStringTest|tests.acqrel.varHandles.byteArray.little.acqrel.DoubleBooleanTest|tests.acqrel.varHandles.byteArray.little.acqrel.DoubleByteTest|tests.acqrel.varHandles.byteArray.little.acqrel.DoubleCharTest|tests.acqrel.varHandles.byteArray.little.acqrel.DoubleFloatTest|tests.acqrel.varHandles.byteArray.little.acqrel.DoubleIntTest|tests.acqrel.varHandles.byteArray.little.acqrel.DoubleShortTest|tests.acqrel.varHandles.byteArray.little.acqrel.DoubleStringTest|tests.acqrel.varHandles.byteArray.little.acqrel.FloatBooleanTest|tests.acqrel.varHandles.byteArray.little.acqrel.FloatByteTest|tests.acqrel.varHandles.byteArray.little.acqrel.FloatCharTest|tests.acqrel.varHandles.byteArray.little.acqrel.FloatFloatTest|tests.acqrel.varHandles.byteArray.little.acqrel.FloatIntTest|tests.acqrel.varHandles.byteArray.little.acqrel.FloatShortTest|tests.acqrel.varHandles.byteArray.little.acqrel.FloatStringTest|tests.acqrel.varHandles.byteArray.little.acqrel.IntBooleanTest|tests.acqrel.varHandles.byteArray.little.acqrel.IntByteTest|tests.acqrel.varHandles.byteArray.little.acqrel.IntCharTest|tests.acqrel.varHandles.byteArray.little.acqrel.IntFloatTest|tests.acqrel.varHandles.byteArray.little.acqrel.IntIntTest|tests.acqrel.varHandles.byteArray.little.acqrel.IntShortTest|tests.acqrel.varHandles.byteArray.little.acqrel.IntStringTest|tests.acqrel.varHandles.byteArray.little.acqrel.LongBooleanTest|tests.acqrel.varHandles.byteArray.little.acqrel.LongByteTest|tests.acqrel.varHandles.byteArray.little.acqrel.LongCharTest|tests.acqrel.varHandles.byteArray.little.acqrel.LongFloatTest|tests.acqrel.varHandles.byteArray.little.acqrel.LongIntTest|tests.acqrel.varHandles.byteArray.little.acqrel.LongShortTest|tests.acqrel.varHandles.byteArray.little.acqrel.LongStringTest|tests.acqrel.varHandles.byteArray.little.acqrel.ShortBooleanTest|tests.acqrel.varHandles.byteArray.little.acqrel.ShortByteTest|tests.acqrel.varHandles.byteArray.little.acqrel.ShortCharTest|tests.acqrel.varHandles.byteArray.little.acqrel.ShortFloatTest|tests.acqrel.varHandles.byteArray.little.acqrel.ShortIntTest|tests.acqrel.varHandles.byteArray.little.acqrel.ShortShortTest|tests.acqrel.varHandles.byteArray.little.acqrel.ShortStringTest|tests.acqrel.varHandles.byteArray.little.volatiles.CharBooleanTest|tests.acqrel.varHandles.byteArray.little.volatiles.CharByteTest|tests.acqrel.varHandles.byteArray.little.volatiles.CharCharTest|tests.acqrel.varHandles.byteArray.little.volatiles.CharFloatTest|tests.acqrel.varHandles.byteArray.little.volatiles.CharIntTest|tests.acqrel.varHandles.byteArray.little.volatiles.CharShortTest|tests.acqrel.varHandles.byteArray.little.volatiles.CharStringTest|tests.acqrel.varHandles.byteArray.little.volatiles.DoubleBooleanTest|tests.acqrel.varHandles.byteArray.little.volatiles.DoubleByteTest|tests.acqrel.varHandles.byteArray.little.volatiles.DoubleCharTest|tests.acqrel.varHandles.byteArray.little.volatiles.DoubleFloatTest|tests.acqrel.varHandles.byteArray.little.volatiles.DoubleIntTest|tests.acqrel.varHandles.byteArray.little.volatiles.DoubleShortTest|tests.acqrel.varHandles.byteArray.little.volatiles.DoubleStringTest|tests.acqrel.varHandles.byteArray.little.volatiles.FloatBooleanTest|tests.acqrel.varHandles.byteArray.little.volatiles.FloatByteTest|tests.acqrel.varHandles.byteArray.little.volatiles.FloatCharTest|tests.acqrel.varHandles.byteArray.little.volatiles.FloatFloatTest|tests.acqrel.varHandles.byteArray.little.volatiles.FloatIntTest|tests.acqrel.varHandles.byteArray.little.volatiles.FloatShortTest|tests.acqrel.varHandles.byteArray.little.volatiles.FloatStringTest|tests.acqrel.varHandles.byteArray.little.volatiles.IntBooleanTest|tests.acqrel.varHandles.byteArray.little.volatiles.IntByteTest|tests.acqrel.varHandles.byteArray.little.volatiles.IntCharTest|tests.acqrel.varHandles.byteArray.little.volatiles.IntFloatTest|tests.acqrel.varHandles.byteArray.little.volatiles.IntIntTest|tests.acqrel.varHandles.byteArray.little.volatiles.IntShortTest|tests.acqrel.varHandles.byteArray.little.volatiles.IntStringTest|tests.acqrel.varHandles.byteArray.little.volatiles.LongBooleanTest|tests.acqrel.varHandles.byteArray.little.volatiles.LongByteTest|tests.acqrel.varHandles.byteArray.little.volatiles.LongCharTest|tests.acqrel.varHandles.byteArray.little.volatiles.LongFloatTest|tests.acqrel.varHandles.byteArray.little.volatiles.LongIntTest|tests.acqrel.varHandles.byteArray.little.volatiles.LongShortTest|tests.acqrel.varHandles.byteArray.little.volatiles.LongStringTest|tests.acqrel.varHandles.byteArray.little.volatiles.ShortBooleanTest|tests.acqrel.varHandles.byteArray.little.volatiles.ShortByteTest|tests.acqrel.varHandles.byteArray.little.volatiles.ShortCharTest|tests.acqrel.varHandles.byteArray.little.volatiles.ShortFloatTest|tests.acqrel.varHandles.byteArray.little.volatiles.ShortIntTest|tests.acqrel.varHandles.byteArray.little.volatiles.ShortShortTest|tests.acqrel.varHandles.byteArray.little.volatiles.ShortStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.varHandles.byteBuffer.direct.big</testCaseName>
+	<!-- 71/82 org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.direct.big: classes 84/tests 168(ac/ar:168/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.CharBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.CharByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.CharCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.CharFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.CharIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.CharShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.CharStringTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.DoubleBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.DoubleByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.DoubleCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.DoubleFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.DoubleIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.DoubleShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.DoubleStringTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.FloatBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.FloatByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.FloatCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.FloatFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.FloatIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.FloatShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.FloatStringTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.IntBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.IntByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.IntCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.IntFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.IntIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.IntShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.IntStringTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.LongBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.LongByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.LongCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.LongFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.LongIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.LongShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.LongStringTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.ShortBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.ShortByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.ShortCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.ShortFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.ShortIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.ShortShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.acqrel.ShortStringTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.CharBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.CharByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.CharCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.CharFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.CharIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.CharShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.CharStringTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.DoubleBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.DoubleByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.DoubleCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.DoubleFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.DoubleIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.DoubleShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.DoubleStringTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.FloatBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.FloatByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.FloatCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.FloatFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.FloatIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.FloatShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.FloatStringTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.IntBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.IntByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.IntCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.IntFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.IntIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.IntShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.IntStringTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.LongBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.LongByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.LongCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.LongFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.LongIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.LongShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.LongStringTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.ShortBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.ShortByteTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.ShortCharTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.ShortFloatTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.ShortIntTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.ShortShortTest|tests.acqrel.varHandles.byteBuffer.direct.big.volatiles.ShortStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.varHandles.byteBuffer.direct.little</testCaseName>
+	<!-- 72/82 org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.direct.little: classes 84/tests 168(ac/ar:168/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.CharBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.CharByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.CharCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.CharFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.CharIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.CharShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.CharStringTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.DoubleBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.DoubleByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.DoubleCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.DoubleFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.DoubleIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.DoubleShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.DoubleStringTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.FloatBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.FloatByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.FloatCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.FloatFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.FloatIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.FloatShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.FloatStringTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.IntBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.IntByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.IntCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.IntFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.IntIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.IntShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.IntStringTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.LongBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.LongByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.LongCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.LongFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.LongIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.LongShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.LongStringTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.ShortBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.ShortByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.ShortCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.ShortFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.ShortIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.ShortShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.acqrel.ShortStringTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.CharBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.CharByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.CharCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.CharFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.CharIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.CharShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.CharStringTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.DoubleBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.DoubleByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.DoubleCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.DoubleFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.DoubleIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.DoubleShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.DoubleStringTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.FloatBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.FloatByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.FloatCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.FloatFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.FloatIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.FloatShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.FloatStringTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.IntBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.IntByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.IntCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.IntFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.IntIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.IntShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.IntStringTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.LongBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.LongByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.LongCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.LongFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.LongIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.LongShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.LongStringTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.ShortBooleanTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.ShortByteTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.ShortCharTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.ShortFloatTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.ShortIntTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.ShortShortTest|tests.acqrel.varHandles.byteBuffer.direct.little.volatiles.ShortStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.varHandles.byteBuffer.heap.big</testCaseName>
+	<!-- 73/82 org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.heap.big: classes 84/tests 168(ac/ar:168/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.CharBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.CharByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.CharCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.CharFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.CharIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.CharShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.CharStringTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.DoubleBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.DoubleByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.DoubleCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.DoubleFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.DoubleIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.DoubleShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.DoubleStringTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.FloatBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.FloatByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.FloatCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.FloatFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.FloatIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.FloatShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.FloatStringTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.IntBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.IntByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.IntCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.IntFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.IntIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.IntShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.IntStringTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.LongBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.LongByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.LongCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.LongFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.LongIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.LongShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.LongStringTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.ShortBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.ShortByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.ShortCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.ShortFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.ShortIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.ShortShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.acqrel.ShortStringTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.CharBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.CharByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.CharCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.CharFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.CharIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.CharShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.CharStringTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.DoubleBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.DoubleByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.DoubleCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.DoubleFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.DoubleIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.DoubleShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.DoubleStringTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.FloatBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.FloatByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.FloatCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.FloatFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.FloatIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.FloatShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.FloatStringTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.IntBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.IntByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.IntCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.IntFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.IntIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.IntShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.IntStringTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.LongBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.LongByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.LongCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.LongFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.LongIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.LongShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.LongStringTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.ShortBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.ShortByteTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.ShortCharTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.ShortFloatTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.ShortIntTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.ShortShortTest|tests.acqrel.varHandles.byteBuffer.heap.big.volatiles.ShortStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.acqrel.varHandles.byteBuffer.heap.little</testCaseName>
+	<!-- 74/82 org.openjdk.jcstress.tests.acqrel.varHandles.byteBuffer.heap.little: classes 84/tests 168(ac/ar:168/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.CharBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.CharByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.CharCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.CharFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.CharIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.CharShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.CharStringTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.DoubleBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.DoubleByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.DoubleCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.DoubleFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.DoubleIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.DoubleShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.DoubleStringTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.FloatBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.FloatByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.FloatCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.FloatFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.FloatIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.FloatShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.FloatStringTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.IntBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.IntByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.IntCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.IntFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.IntIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.IntShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.IntStringTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.LongBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.LongByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.LongCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.LongFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.LongIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.LongShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.LongStringTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.ShortBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.ShortByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.ShortCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.ShortFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.ShortIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.ShortShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.acqrel.ShortStringTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.CharBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.CharByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.CharCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.CharFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.CharIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.CharShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.CharStringTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.DoubleBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.DoubleByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.DoubleCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.DoubleFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.DoubleIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.DoubleShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.DoubleStringTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.FloatBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.FloatByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.FloatCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.FloatFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.FloatIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.FloatShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.FloatStringTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.IntBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.IntByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.IntCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.IntFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.IntIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.IntShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.IntStringTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.LongBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.LongByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.LongCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.LongFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.LongIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.LongShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.LongStringTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.ShortBooleanTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.ShortByteTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.ShortCharTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.ShortFloatTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.ShortIntTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.ShortShortTest|tests.acqrel.varHandles.byteBuffer.heap.little.volatiles.ShortStringTest"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.memeffects.basic.atomic.AtomicInteger</testCaseName>
+	<!-- 75/82 org.openjdk.jcstress.tests.memeffects.basic.atomic.AtomicInteger: classes 96/tests 192(ac/ar:192/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_compareAndSet_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_compareAndSet_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_compareAndSet_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_compareAndSet_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_compareAndSet_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_compareAndSet_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndAdd_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndAdd_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndAdd_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndAdd_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndAdd_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndAdd_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndSet_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndSet_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndSet_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndSet_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndSet_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_getAndSet_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_set_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_set_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_set_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_set_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_set_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_compareAndSet_set_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_compareAndSet_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_compareAndSet_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_compareAndSet_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_compareAndSet_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_compareAndSet_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_compareAndSet_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndAdd_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndAdd_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndAdd_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndAdd_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndAdd_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndAdd_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndSet_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndSet_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndSet_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndSet_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndSet_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_getAndSet_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_set_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_set_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_set_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_set_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_set_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndAdd_set_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_compareAndSet_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_compareAndSet_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_compareAndSet_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_compareAndSet_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_compareAndSet_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_compareAndSet_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndAdd_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndAdd_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndAdd_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndAdd_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndAdd_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndAdd_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndSet_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndSet_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndSet_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndSet_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndSet_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_getAndSet_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_set_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_set_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_set_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_set_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_set_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_getAndSet_set_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_compareAndSet_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_compareAndSet_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_compareAndSet_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_compareAndSet_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_compareAndSet_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_compareAndSet_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndAdd_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndAdd_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndAdd_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndAdd_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndAdd_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndAdd_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndSet_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndSet_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndSet_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndSet_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndSet_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_getAndSet_short|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_set_byte|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_set_double|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_set_float|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_set_int|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_set_long|tests.memeffects.basic.atomic.AtomicInteger.atomic_get_set_short"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.memeffects.basic.atomic.AtomicLong</testCaseName>
+	<!-- 76/82 org.openjdk.jcstress.tests.memeffects.basic.atomic.AtomicLong: classes 96/tests 192(ac/ar:192/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_compareAndSet_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_compareAndSet_double|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_compareAndSet_float|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_compareAndSet_int|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_compareAndSet_long|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_compareAndSet_short|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndAdd_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndAdd_double|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndAdd_float|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndAdd_int|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndAdd_long|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndAdd_short|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndSet_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndSet_double|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndSet_float|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndSet_int|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndSet_long|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_getAndSet_short|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_set_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_set_double|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_set_float|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_set_int|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_set_long|tests.memeffects.basic.atomic.AtomicLong.atomic_compareAndSet_set_short|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_compareAndSet_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_compareAndSet_double|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_compareAndSet_float|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_compareAndSet_int|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_compareAndSet_long|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_compareAndSet_short|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndAdd_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndAdd_double|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndAdd_float|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndAdd_int|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndAdd_long|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndAdd_short|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndSet_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndSet_double|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndSet_float|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndSet_int|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndSet_long|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_getAndSet_short|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_set_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_set_double|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_set_float|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_set_int|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_set_long|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndAdd_set_short|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_compareAndSet_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_compareAndSet_double|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_compareAndSet_float|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_compareAndSet_int|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_compareAndSet_long|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_compareAndSet_short|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndAdd_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndAdd_double|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndAdd_float|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndAdd_int|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndAdd_long|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndAdd_short|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndSet_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndSet_double|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndSet_float|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndSet_int|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndSet_long|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_getAndSet_short|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_set_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_set_double|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_set_float|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_set_int|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_set_long|tests.memeffects.basic.atomic.AtomicLong.atomic_getAndSet_set_short|tests.memeffects.basic.atomic.AtomicLong.atomic_get_compareAndSet_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_get_compareAndSet_double|tests.memeffects.basic.atomic.AtomicLong.atomic_get_compareAndSet_float|tests.memeffects.basic.atomic.AtomicLong.atomic_get_compareAndSet_int|tests.memeffects.basic.atomic.AtomicLong.atomic_get_compareAndSet_long|tests.memeffects.basic.atomic.AtomicLong.atomic_get_compareAndSet_short|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndAdd_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndAdd_double|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndAdd_float|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndAdd_int|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndAdd_long|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndAdd_short|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndSet_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndSet_double|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndSet_float|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndSet_int|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndSet_long|tests.memeffects.basic.atomic.AtomicLong.atomic_get_getAndSet_short|tests.memeffects.basic.atomic.AtomicLong.atomic_get_set_byte|tests.memeffects.basic.atomic.AtomicLong.atomic_get_set_double|tests.memeffects.basic.atomic.AtomicLong.atomic_get_set_float|tests.memeffects.basic.atomic.AtomicLong.atomic_get_set_int|tests.memeffects.basic.atomic.AtomicLong.atomic_get_set_long|tests.memeffects.basic.atomic.AtomicLong.atomic_get_set_short"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater</testCaseName>
+	<!-- 77/82 org.openjdk.jcstress.tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater: classes 96/tests 192(ac/ar:192/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_compareAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_compareAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_compareAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_compareAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_compareAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_compareAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndAdd_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndAdd_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndAdd_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndAdd_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndAdd_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndAdd_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_getAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_set_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_set_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_set_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_set_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_set_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_compareAndSet_set_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_compareAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_compareAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_compareAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_compareAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_compareAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_compareAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndAdd_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndAdd_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndAdd_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndAdd_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndAdd_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndAdd_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_getAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_set_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_set_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_set_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_set_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_set_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndAdd_set_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_compareAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_compareAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_compareAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_compareAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_compareAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_compareAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndAdd_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndAdd_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndAdd_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndAdd_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndAdd_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndAdd_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_getAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_set_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_set_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_set_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_set_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_set_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_getAndSet_set_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_compareAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_compareAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_compareAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_compareAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_compareAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_compareAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndAdd_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndAdd_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndAdd_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndAdd_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndAdd_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndAdd_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_getAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_set_byte|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_set_double|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_set_float|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_set_int|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_set_long|tests.memeffects.basic.atomicupdaters.AtomicIntegerFieldUpdater.atomic_get_set_short"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater</testCaseName>
+	<!-- 78/82 org.openjdk.jcstress.tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater: classes 96/tests 192(ac/ar:192/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_compareAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_compareAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_compareAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_compareAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_compareAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_compareAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndAdd_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndAdd_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndAdd_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndAdd_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndAdd_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndAdd_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_getAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_set_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_set_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_set_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_set_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_set_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_compareAndSet_set_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_compareAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_compareAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_compareAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_compareAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_compareAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_compareAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndAdd_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndAdd_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndAdd_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndAdd_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndAdd_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndAdd_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_getAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_set_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_set_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_set_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_set_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_set_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndAdd_set_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_compareAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_compareAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_compareAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_compareAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_compareAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_compareAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndAdd_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndAdd_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndAdd_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndAdd_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndAdd_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndAdd_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_getAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_set_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_set_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_set_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_set_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_set_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_getAndSet_set_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_compareAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_compareAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_compareAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_compareAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_compareAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_compareAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndAdd_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndAdd_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndAdd_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndAdd_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndAdd_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndAdd_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndSet_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndSet_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndSet_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndSet_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndSet_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_getAndSet_short|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_set_byte|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_set_double|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_set_float|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_set_int|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_set_long|tests.memeffects.basic.atomicupdaters.AtomicLongFieldUpdater.atomic_get_set_short"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.fences.varHandles</testCaseName>
+	<!-- 79/82 org.openjdk.jcstress.tests.fences.varHandles: classes 98/tests 196(ac/ar:196/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.fences.varHandles.LoadLoadFenceTest.AcquireFenceBoolean|tests.fences.varHandles.LoadLoadFenceTest.AcquireFenceByte|tests.fences.varHandles.LoadLoadFenceTest.AcquireFenceChar|tests.fences.varHandles.LoadLoadFenceTest.AcquireFenceFloat|tests.fences.varHandles.LoadLoadFenceTest.AcquireFenceInt|tests.fences.varHandles.LoadLoadFenceTest.AcquireFenceShort|tests.fences.varHandles.LoadLoadFenceTest.AcquireFenceString|tests.fences.varHandles.LoadLoadFenceTest.FullFenceBoolean|tests.fences.varHandles.LoadLoadFenceTest.FullFenceByte|tests.fences.varHandles.LoadLoadFenceTest.FullFenceChar|tests.fences.varHandles.LoadLoadFenceTest.FullFenceFloat|tests.fences.varHandles.LoadLoadFenceTest.FullFenceInt|tests.fences.varHandles.LoadLoadFenceTest.FullFenceShort|tests.fences.varHandles.LoadLoadFenceTest.FullFenceString|tests.fences.varHandles.LoadLoadFenceTest.LoadLoadFenceBoolean|tests.fences.varHandles.LoadLoadFenceTest.LoadLoadFenceByte|tests.fences.varHandles.LoadLoadFenceTest.LoadLoadFenceChar|tests.fences.varHandles.LoadLoadFenceTest.LoadLoadFenceFloat|tests.fences.varHandles.LoadLoadFenceTest.LoadLoadFenceInt|tests.fences.varHandles.LoadLoadFenceTest.LoadLoadFenceShort|tests.fences.varHandles.LoadLoadFenceTest.LoadLoadFenceString|tests.fences.varHandles.LoadStoreFenceTest1.FullFenceBoolean|tests.fences.varHandles.LoadStoreFenceTest1.FullFenceByte|tests.fences.varHandles.LoadStoreFenceTest1.FullFenceChar|tests.fences.varHandles.LoadStoreFenceTest1.FullFenceFloat|tests.fences.varHandles.LoadStoreFenceTest1.FullFenceInt|tests.fences.varHandles.LoadStoreFenceTest1.FullFenceShort|tests.fences.varHandles.LoadStoreFenceTest1.FullFenceString|tests.fences.varHandles.LoadStoreFenceTest1.ReleaseFenceBoolean|tests.fences.varHandles.LoadStoreFenceTest1.ReleaseFenceByte|tests.fences.varHandles.LoadStoreFenceTest1.ReleaseFenceChar|tests.fences.varHandles.LoadStoreFenceTest1.ReleaseFenceFloat|tests.fences.varHandles.LoadStoreFenceTest1.ReleaseFenceInt|tests.fences.varHandles.LoadStoreFenceTest1.ReleaseFenceShort|tests.fences.varHandles.LoadStoreFenceTest1.ReleaseFenceString|tests.fences.varHandles.LoadStoreFenceTest2.AcquireFenceBoolean|tests.fences.varHandles.LoadStoreFenceTest2.AcquireFenceByte|tests.fences.varHandles.LoadStoreFenceTest2.AcquireFenceChar|tests.fences.varHandles.LoadStoreFenceTest2.AcquireFenceFloat|tests.fences.varHandles.LoadStoreFenceTest2.AcquireFenceInt|tests.fences.varHandles.LoadStoreFenceTest2.AcquireFenceShort|tests.fences.varHandles.LoadStoreFenceTest2.AcquireFenceString|tests.fences.varHandles.LoadStoreFenceTest2.FullFenceBoolean|tests.fences.varHandles.LoadStoreFenceTest2.FullFenceByte|tests.fences.varHandles.LoadStoreFenceTest2.FullFenceChar|tests.fences.varHandles.LoadStoreFenceTest2.FullFenceFloat|tests.fences.varHandles.LoadStoreFenceTest2.FullFenceInt|tests.fences.varHandles.LoadStoreFenceTest2.FullFenceShort|tests.fences.varHandles.LoadStoreFenceTest2.FullFenceString|tests.fences.varHandles.StoreLoadFenceTest.FullFenceBoolean|tests.fences.varHandles.StoreLoadFenceTest.FullFenceByte|tests.fences.varHandles.StoreLoadFenceTest.FullFenceChar|tests.fences.varHandles.StoreLoadFenceTest.FullFenceFloat|tests.fences.varHandles.StoreLoadFenceTest.FullFenceInt|tests.fences.varHandles.StoreLoadFenceTest.FullFenceShort|tests.fences.varHandles.StoreLoadFenceTest.FullFenceString|tests.fences.varHandles.StoreStoreFenceTest1.FullFenceBoolean|tests.fences.varHandles.StoreStoreFenceTest1.FullFenceByte|tests.fences.varHandles.StoreStoreFenceTest1.FullFenceChar|tests.fences.varHandles.StoreStoreFenceTest1.FullFenceFloat|tests.fences.varHandles.StoreStoreFenceTest1.FullFenceInt|tests.fences.varHandles.StoreStoreFenceTest1.FullFenceShort|tests.fences.varHandles.StoreStoreFenceTest1.FullFenceString|tests.fences.varHandles.StoreStoreFenceTest1.ReleaseFenceBoolean|tests.fences.varHandles.StoreStoreFenceTest1.ReleaseFenceByte|tests.fences.varHandles.StoreStoreFenceTest1.ReleaseFenceChar|tests.fences.varHandles.StoreStoreFenceTest1.ReleaseFenceFloat|tests.fences.varHandles.StoreStoreFenceTest1.ReleaseFenceInt|tests.fences.varHandles.StoreStoreFenceTest1.ReleaseFenceShort|tests.fences.varHandles.StoreStoreFenceTest1.ReleaseFenceString|tests.fences.varHandles.StoreStoreFenceTest1.StoreStoreFenceBoolean|tests.fences.varHandles.StoreStoreFenceTest1.StoreStoreFenceByte|tests.fences.varHandles.StoreStoreFenceTest1.StoreStoreFenceChar|tests.fences.varHandles.StoreStoreFenceTest1.StoreStoreFenceFloat|tests.fences.varHandles.StoreStoreFenceTest1.StoreStoreFenceInt|tests.fences.varHandles.StoreStoreFenceTest1.StoreStoreFenceShort|tests.fences.varHandles.StoreStoreFenceTest1.StoreStoreFenceString|tests.fences.varHandles.StoreStoreFenceTest2.FullFenceBoolean|tests.fences.varHandles.StoreStoreFenceTest2.FullFenceByte|tests.fences.varHandles.StoreStoreFenceTest2.FullFenceChar|tests.fences.varHandles.StoreStoreFenceTest2.FullFenceFloat|tests.fences.varHandles.StoreStoreFenceTest2.FullFenceInt|tests.fences.varHandles.StoreStoreFenceTest2.FullFenceShort|tests.fences.varHandles.StoreStoreFenceTest2.FullFenceString|tests.fences.varHandles.StoreStoreFenceTest2.ReleaseFenceBoolean|tests.fences.varHandles.StoreStoreFenceTest2.ReleaseFenceByte|tests.fences.varHandles.StoreStoreFenceTest2.ReleaseFenceChar|tests.fences.varHandles.StoreStoreFenceTest2.ReleaseFenceFloat|tests.fences.varHandles.StoreStoreFenceTest2.ReleaseFenceInt|tests.fences.varHandles.StoreStoreFenceTest2.ReleaseFenceShort|tests.fences.varHandles.StoreStoreFenceTest2.ReleaseFenceString|tests.fences.varHandles.StoreStoreFenceTest2.StoreStoreFenceBoolean|tests.fences.varHandles.StoreStoreFenceTest2.StoreStoreFenceByte|tests.fences.varHandles.StoreStoreFenceTest2.StoreStoreFenceChar|tests.fences.varHandles.StoreStoreFenceTest2.StoreStoreFenceFloat|tests.fences.varHandles.StoreStoreFenceTest2.StoreStoreFenceInt|tests.fences.varHandles.StoreStoreFenceTest2.StoreStoreFenceShort|tests.fences.varHandles.StoreStoreFenceTest2.StoreStoreFenceString"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.locks.stamped.StampedLockPairwiseTests</testCaseName>
+	<!-- 80/82 org.openjdk.jcstress.tests.locks.stamped.StampedLockPairwiseTests: classes 225/tests 450(ac/ar:450/0)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_URs.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_Us.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.RLI_tUR.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_URs.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_Us.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.RL_tUR.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.aRL_U.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.aRWLr_U.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.tOR_V.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_URs.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_Us.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.tRL_tUR.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_URs.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_Us.tWLt_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.WLI_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.WLI_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.WLI_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.WL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.WL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.WL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.aRWLw_U|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.aWL_U|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.orWL_V|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.tWL_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.tWL_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.tWL_tUW|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.tWLt_UWs|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.tWLt_Us|tests.locks.stamped.StampedLockPairwiseTests.tRLt_tUR.tWLt_tUW"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.seqcst.sync</testCaseName>
+	<!-- 81/82 org.openjdk.jcstress.tests.seqcst.sync: classes 489/tests 2131(ac/ar:1642/489)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.seqcst.sync.L1_L1_L1__S1_Test|tests.seqcst.sync.L1_L1_L1__S1__S1_Test|tests.seqcst.sync.L1_L1_L1__S1__S1__S1_Test|tests.seqcst.sync.L1_L1_L1__S1__S2__S2_Test|tests.seqcst.sync.L1_L1_L2__S1__S1__S2_Test|tests.seqcst.sync.L1_L1_L2__S1__S2_Test|tests.seqcst.sync.L1_L1_L2__S1__S2__S2_Test|tests.seqcst.sync.L1_L1_S1__S1_Test|tests.seqcst.sync.L1_L1_S1__S1__S1_Test|tests.seqcst.sync.L1_L1_S1__S1__S1__S1_Test|tests.seqcst.sync.L1_L1_S1__S1__S2__S2_Test|tests.seqcst.sync.L1_L1_S2__S1__S1__S2_Test|tests.seqcst.sync.L1_L1_S2__S1__S2_Test|tests.seqcst.sync.L1_L1_S2__S1__S2__S2_Test|tests.seqcst.sync.L1_L1__L1_L1__S1_Test|tests.seqcst.sync.L1_L1__L1_L1__S1__S1_Test|tests.seqcst.sync.L1_L1__L1_L2__S1__S2_Test|tests.seqcst.sync.L1_L1__L1_S1_Test|tests.seqcst.sync.L1_L1__L1_S1__S1_Test|tests.seqcst.sync.L1_L1__L1_S1__S1__S1_Test|tests.seqcst.sync.L1_L1__L1_S1__S2__S2_Test|tests.seqcst.sync.L1_L1__L1_S2__S1__S2_Test|tests.seqcst.sync.L1_L1__L2_L1__S1__S2_Test|tests.seqcst.sync.L1_L1__L2_L2__S1__S2_Test|tests.seqcst.sync.L1_L1__L2_S1__S1__S2_Test|tests.seqcst.sync.L1_L1__L2_S1__S2_Test|tests.seqcst.sync.L1_L1__L2_S1__S2__S2_Test|tests.seqcst.sync.L1_L1__L2_S2__S1__S2_Test|tests.seqcst.sync.L1_L1__S1_L1_Test|tests.seqcst.sync.L1_L1__S1_L1__S2__S2_Test|tests.seqcst.sync.L1_L1__S1_L2__S2_Test|tests.seqcst.sync.L1_L1__S1_L2__S2__S2_Test|tests.seqcst.sync.L1_L1__S1_S1_Test|tests.seqcst.sync.L1_L1__S1_S1__S2__S2_Test|tests.seqcst.sync.L1_L1__S1_S2__S2_Test|tests.seqcst.sync.L1_L1__S1_S2__S2__S2_Test|tests.seqcst.sync.L1_L1__S1_Test|tests.seqcst.sync.L1_L1__S1__S1_L1_Test|tests.seqcst.sync.L1_L1__S1__S1_L2__S2_Test|tests.seqcst.sync.L1_L1__S1__S1_S1_Test|tests.seqcst.sync.L1_L1__S1__S1_S2__S2_Test|tests.seqcst.sync.L1_L1__S1__S1__S1_L1_Test|tests.seqcst.sync.L1_L1__S1__S1__S1_S1_Test|tests.seqcst.sync.L1_L1__S1__S2__S2_L1_Test|tests.seqcst.sync.L1_L1__S1__S2__S2_L2_Test|tests.seqcst.sync.L1_L1__S1__S2__S2_S1_Test|tests.seqcst.sync.L1_L1__S1__S2__S2_S2_Test|tests.seqcst.sync.L1_L1__S2__S2_S1_Test|tests.seqcst.sync.L1_L1__S2__S2__S2_S1_Test|tests.seqcst.sync.L1_L2_L1__S1__S1__S2_Test|tests.seqcst.sync.L1_L2_L1__S1__S2_Test|tests.seqcst.sync.L1_L2_L1__S1__S2__S2_Test|tests.seqcst.sync.L1_L2_L2__S1__S1__S2_Test|tests.seqcst.sync.L1_L2_L2__S1__S2_Test|tests.seqcst.sync.L1_L2_L2__S1__S2__S2_Test|tests.seqcst.sync.L1_L2_L3__S1_S2__S3_Test|tests.seqcst.sync.L1_L2_L3__S1_S3__S2_Test|tests.seqcst.sync.L1_L2_L3__S1__S2_S3_Test|tests.seqcst.sync.L1_L2_L3__S1__S3_S2_Test|tests.seqcst.sync.L1_L2_L3__S2_S1__S3_Test|tests.seqcst.sync.L1_L2_L3__S2__S3_S1_Test|tests.seqcst.sync.L1_L2_S1__S1__S1__S2_Test|tests.seqcst.sync.L1_L2_S1__S1__S2_Test|tests.seqcst.sync.L1_L2_S1__S1__S2__S2_Test|tests.seqcst.sync.L1_L2_S2__S1__S1__S2_Test|tests.seqcst.sync.L1_L2_S2__S1__S2_Test|tests.seqcst.sync.L1_L2_S2__S1__S2__S2_Test|tests.seqcst.sync.L1_L2_S3__L3_S1__S2_Test|tests.seqcst.sync.L1_L2_S3__L3_S2__S1_Test|tests.seqcst.sync.L1_L2_S3__S1_L3__S2_Test|tests.seqcst.sync.L1_L2_S3__S1_S2__S3_Test|tests.seqcst.sync.L1_L2_S3__S1_S3__S2_Test|tests.seqcst.sync.L1_L2_S3__S1__S2_L3_Test|tests.seqcst.sync.L1_L2_S3__S1__S2_S3_Test|tests.seqcst.sync.L1_L2_S3__S1__S3_S2_Test|tests.seqcst.sync.L1_L2_S3__S2_S1__S3_Test|tests.seqcst.sync.L1_L2_S3__S2__S3_S1_Test|tests.seqcst.sync.L1_L2__L1_L2__S1__S2_Test|tests.seqcst.sync.L1_L2__L1_S1__S1__S2_Test|tests.seqcst.sync.L1_L2__L1_S1__S2_Test|tests.seqcst.sync.L1_L2__L1_S1__S2__S2_Test|tests.seqcst.sync.L1_L2__L1_S2__S1_Test|tests.seqcst.sync.L1_L2__L1_S2__S1__S1_Test|tests.seqcst.sync.L1_L2__L1_S2__S1__S2_Test|tests.seqcst.sync.L1_L2__L2_L1__S1__S2_Test|tests.seqcst.sync.L1_L2__L2_L2__S1__S2_Test|tests.seqcst.sync.L1_L2__L2_S1__S1__S2_Test|tests.seqcst.sync.L1_L2__L2_S1__S2_Test|tests.seqcst.sync.L1_L2__L2_S1__S2__S2_Test|tests.seqcst.sync.L1_L2__L2_S2__S1_Test|tests.seqcst.sync.L1_L2__L2_S2__S1__S1_Test|tests.seqcst.sync.L1_L2__L2_S2__S1__S2_Test|tests.seqcst.sync.L1_L2__L3_S1__S2_S3_Test|tests.seqcst.sync.L1_L2__L3_S1__S3_S2_Test|tests.seqcst.sync.L1_L2__L3_S2__S1_S3_Test|tests.seqcst.sync.L1_L2__L3_S2__S3_S1_Test|tests.seqcst.sync.L1_L2__S1_L1__S2_Test|tests.seqcst.sync.L1_L2__S1_L1__S2__S2_Test|tests.seqcst.sync.L1_L2__S1_L2__S2_Test|tests.seqcst.sync.L1_L2__S1_L2__S2__S2_Test|tests.seqcst.sync.L1_L2__S1_L3__S2_S3_Test|tests.seqcst.sync.L1_L2__S1_L3__S3_S2_Test|tests.seqcst.sync.L1_L2__S1_S1__S2_Test|tests.seqcst.sync.L1_L2__S1_S1__S2__S2_Test|tests.seqcst.sync.L1_L2__S1_S2_L3__S3_Test|tests.seqcst.sync.L1_L2__S1_S2_S3__S3_Test|tests.seqcst.sync.L1_L2__S1_S2_Test|tests.seqcst.sync.L1_L2__S1_S2__S2_Test|tests.seqcst.sync.L1_L2__S1_S2__S2__S2_Test|tests.seqcst.sync.L1_L2__S1_S3__S2_L3_Test|tests.seqcst.sync.L1_L2__S1_S3__S2_S3_Test|tests.seqcst.sync.L1_L2__S1_S3__S3_S2_Test|tests.seqcst.sync.L1_L2__S1__S1_L1__S2_Test|tests.seqcst.sync.L1_L2__S1__S1_L2__S2_Test|tests.seqcst.sync.L1_L2__S1__S1_S1__S2_Test|tests.seqcst.sync.L1_L2__S1__S1_S2_Test|tests.seqcst.sync.L1_L2__S1__S1_S2__S2_Test|tests.seqcst.sync.L1_L2__S1__S1__S1_S2_Test|tests.seqcst.sync.L1_L2__S1__S1__S2_L1_Test|tests.seqcst.sync.L1_L2__S1__S1__S2_L2_Test|tests.seqcst.sync.L1_L2__S1__S1__S2_S1_Test|tests.seqcst.sync.L1_L2__S1__S1__S2_S2_Test|tests.seqcst.sync.L1_L2__S1__S2_L1_Test|tests.seqcst.sync.L1_L2__S1__S2_L2_Test|tests.seqcst.sync.L1_L2__S1__S2_S1_Test|tests.seqcst.sync.L1_L2__S1__S2_S2_Test|tests.seqcst.sync.L1_L2__S1__S2_Test|tests.seqcst.sync.L1_L2__S1__S2__S2_L1_Test|tests.seqcst.sync.L1_L2__S1__S2__S2_L2_Test|tests.seqcst.sync.L1_L2__S1__S2__S2_S1_Test|tests.seqcst.sync.L1_L2__S1__S2__S2_S2_Test|tests.seqcst.sync.L1_L2__S2_L3__S3_S1_Test|tests.seqcst.sync.L1_L2__S2_S1_Test|tests.seqcst.sync.L1_L2__S2_S3__S3_S1_Test|tests.seqcst.sync.L1_L2__S2__S2_S1_Test|tests.seqcst.sync.L1_L2__S2__S2__S2_S1_Test|tests.seqcst.sync.L1_L2__S3_S1__S3_S2_Test|tests.seqcst.sync.L1_L3__S1_L2_S3__S2_Test|tests.seqcst.sync.L1_L3__S1_S2_S3__S2_Test|tests.seqcst.sync.L1_S1_L1__S1_Test|tests.seqcst.sync.L1_S1_L1__S1__S1_Test|tests.seqcst.sync.L1_S1_L1__S1__S1__S1_Test|tests.seqcst.sync.L1_S1_L1__S1__S2__S2_Test|tests.seqcst.sync.L1_S1_L2__S1__S1__S2_Test|tests.seqcst.sync.L1_S1_L2__S1__S2_Test|tests.seqcst.sync.L1_S1_L2__S1__S2__S2_Test|tests.seqcst.sync.L1_S1_S1__S1_Test|tests.seqcst.sync.L1_S1_S1__S1__S1_Test|tests.seqcst.sync.L1_S1_S1__S1__S1__S1_Test|tests.seqcst.sync.L1_S1_S1__S1__S2__S2_Test|tests.seqcst.sync.L1_S1_S2__S1__S1__S2_Test|tests.seqcst.sync.L1_S1_S2__S1__S2_Test|tests.seqcst.sync.L1_S1_S2__S1__S2__S2_Test|tests.seqcst.sync.L1_S1__L1_S1_Test|tests.seqcst.sync.L1_S1__L1_S1__S1_Test|tests.seqcst.sync.L1_S1__L1_S1__S1__S1_Test|tests.seqcst.sync.L1_S1__L1_S1__S2__S2_Test|tests.seqcst.sync.L1_S1__L1_S2__S1__S2_Test|tests.seqcst.sync.L1_S1__L1_S2__S2_Test|tests.seqcst.sync.L1_S1__L1_S2__S2__S2_Test|tests.seqcst.sync.L1_S1__L2_S1__S1__S2_Test|tests.seqcst.sync.L1_S1__L2_S1__S2_Test|tests.seqcst.sync.L1_S1__L2_S1__S2__S2_Test|tests.seqcst.sync.L1_S1__L2_S2__S1__S2_Test|tests.seqcst.sync.L1_S1__S1_L1_Test|tests.seqcst.sync.L1_S1__S1_L1__S2__S2_Test|tests.seqcst.sync.L1_S1__S1_L2__S2_Test|tests.seqcst.sync.L1_S1__S1_L2__S2__S2_Test|tests.seqcst.sync.L1_S1__S1_S1_Test|tests.seqcst.sync.L1_S1__S1_S1__S2__S2_Test|tests.seqcst.sync.L1_S1__S1_S2__S2_Test|tests.seqcst.sync.L1_S1__S1_S2__S2__S2_Test|tests.seqcst.sync.L1_S1__S1_Test|tests.seqcst.sync.L1_S1__S1__S1_L1_Test|tests.seqcst.sync.L1_S1__S1__S1_L2__S2_Test|tests.seqcst.sync.L1_S1__S1__S1_S1_Test|tests.seqcst.sync.L1_S1__S1__S1_S2__S2_Test|tests.seqcst.sync.L1_S1__S1__S1__S1_L1_Test|tests.seqcst.sync.L1_S1__S1__S1__S1_S1_Test|tests.seqcst.sync.L1_S1__S1__S2__S2_L1_Test|tests.seqcst.sync.L1_S1__S1__S2__S2_L2_Test|tests.seqcst.sync.L1_S1__S1__S2__S2_S1_Test|tests.seqcst.sync.L1_S1__S1__S2__S2_S2_Test|tests.seqcst.sync.L1_S1__S2__S2_L1_Test|tests.seqcst.sync.L1_S1__S2__S2_S1_Test|tests.seqcst.sync.L1_S1__S2__S2__S2_L1_Test|tests.seqcst.sync.L1_S1__S2__S2__S2_S1_Test|tests.seqcst.sync.L1_S2_L1__S1__S1__S2_Test|tests.seqcst.sync.L1_S2_L1__S1__S2_Test|tests.seqcst.sync.L1_S2_L1__S1__S2__S2_Test|tests.seqcst.sync.L1_S2_L2__S1__S1__S2_Test|tests.seqcst.sync.L1_S2_L2__S1__S2_Test|tests.seqcst.sync.L1_S2_L2__S1__S2__S2_Test|tests.seqcst.sync.L1_S2_L3__L2_S1__S3_Test|tests.seqcst.sync.L1_S2_L3__L2_S3__S1_Test|tests.seqcst.sync.L1_S2_L3__S1_L2__S3_Test|tests.seqcst.sync.L1_S2_L3__S1_S2__S3_Test|tests.seqcst.sync.L1_S2_L3__S1_S3__S2_Test|tests.seqcst.sync.L1_S2_L3__S1__S2_S3_Test|tests.seqcst.sync.L1_S2_L3__S1__S3_L2_Test|tests.seqcst.sync.L1_S2_L3__S1__S3_S2_Test|tests.seqcst.sync.L1_S2_L3__S2_S1__S3_Test|tests.seqcst.sync.L1_S2_L3__S2__S3_S1_Test|tests.seqcst.sync.L1_S2_S1__S1__S1__S2_Test|tests.seqcst.sync.L1_S2_S1__S1__S2_Test|tests.seqcst.sync.L1_S2_S1__S1__S2__S2_Test|tests.seqcst.sync.L1_S2_S2__S1__S1__S2_Test|tests.seqcst.sync.L1_S2_S2__S1__S2_Test|tests.seqcst.sync.L1_S2_S2__S1__S2__S2_Test|tests.seqcst.sync.L1_S2_S3__L2_L3__S1_Test|tests.seqcst.sync.L1_S2_S3__L2_S1__S3_Test|tests.seqcst.sync.L1_S2_S3__L2_S3__S1_Test|tests.seqcst.sync.L1_S2_S3__L3_L2__S1_Test|tests.seqcst.sync.L1_S2_S3__L3_S1__S2_Test|tests.seqcst.sync.L1_S2_S3__L3_S2__S1_Test|tests.seqcst.sync.L1_S2_S3__S1_L2__S3_Test|tests.seqcst.sync.L1_S2_S3__S1_L3__S2_Test|tests.seqcst.sync.L1_S2_S3__S1_S2__S3_Test|tests.seqcst.sync.L1_S2_S3__S1_S3__S2_Test|tests.seqcst.sync.L1_S2_S3__S1__S2_L3_Test|tests.seqcst.sync.L1_S2_S3__S1__S2_S3_Test|tests.seqcst.sync.L1_S2_S3__S1__S3_L2_Test|tests.seqcst.sync.L1_S2_S3__S1__S3_S2_Test|tests.seqcst.sync.L1_S2_S3__S2_S1__S3_Test|tests.seqcst.sync.L1_S2_S3__S2__S3_S1_Test|tests.seqcst.sync.L1_S2__L1_S2__S1_Test|tests.seqcst.sync.L1_S2__L1_S2__S1__S1_Test|tests.seqcst.sync.L1_S2__L1_S2__S1__S2_Test|tests.seqcst.sync.L1_S2__L2_S1_Test|tests.seqcst.sync.L1_S2__L2_S1__S1_Test|tests.seqcst.sync.L1_S2__L2_S1__S1__S1_Test|tests.seqcst.sync.L1_S2__L2_S1__S1__S2_Test|tests.seqcst.sync.L1_S2__L2_S1__S2_Test|tests.seqcst.sync.L1_S2__L2_S1__S2__S2_Test|tests.seqcst.sync.L1_S2__L2_S2__S1_Test|tests.seqcst.sync.L1_S2__L2_S2__S1__S1_Test|tests.seqcst.sync.L1_S2__L2_S2__S1__S2_Test|tests.seqcst.sync.L1_S2__L2_S3__L3_S1_Test|tests.seqcst.sync.L1_S2__L2_S3__S1_L3_Test|tests.seqcst.sync.L1_S2__L2_S3__S1_S3_Test|tests.seqcst.sync.L1_S2__L2_S3__S3_S1_Test|tests.seqcst.sync.L1_S2__L3_S1__S2_S3_Test|tests.seqcst.sync.L1_S2__L3_S1__S3_L2_Test|tests.seqcst.sync.L1_S2__L3_S1__S3_S2_Test|tests.seqcst.sync.L1_S2__L3_S2__S1_S3_Test|tests.seqcst.sync.L1_S2__L3_S2__S3_S1_Test|tests.seqcst.sync.L1_S2__S1_L1__S2_Test|tests.seqcst.sync.L1_S2__S1_L1__S2__S2_Test|tests.seqcst.sync.L1_S2__S1_L2_L3__S3_Test|tests.seqcst.sync.L1_S2__S1_L2_S3__S3_Test|tests.seqcst.sync.L1_S2__S1_L2_Test|tests.seqcst.sync.L1_S2__S1_L2__S2_Test|tests.seqcst.sync.L1_S2__S1_L2__S2__S2_Test|tests.seqcst.sync.L1_S2__S1_L3__S2_S3_Test|tests.seqcst.sync.L1_S2__S1_L3__S3_L2_Test|tests.seqcst.sync.L1_S2__S1_L3__S3_S2_Test|tests.seqcst.sync.L1_S2__S1_S1__S2_Test|tests.seqcst.sync.L1_S2__S1_S1__S2__S2_Test|tests.seqcst.sync.L1_S2__S1_S2_L3__S3_Test|tests.seqcst.sync.L1_S2__S1_S2_S3__S3_Test|tests.seqcst.sync.L1_S2__S1_S2_Test|tests.seqcst.sync.L1_S2__S1_S2__S2_Test|tests.seqcst.sync.L1_S2__S1_S2__S2__S2_Test|tests.seqcst.sync.L1_S2__S1_S3__S2_L3_Test|tests.seqcst.sync.L1_S2__S1_S3__S2_S3_Test|tests.seqcst.sync.L1_S2__S1_S3__S3_L2_Test|tests.seqcst.sync.L1_S2__S1_S3__S3_S2_Test|tests.seqcst.sync.L1_S2__S1__S1_L1__S2_Test|tests.seqcst.sync.L1_S2__S1__S1_L2_Test|tests.seqcst.sync.L1_S2__S1__S1_L2__S2_Test|tests.seqcst.sync.L1_S2__S1__S1_S1__S2_Test|tests.seqcst.sync.L1_S2__S1__S1_S2_Test|tests.seqcst.sync.L1_S2__S1__S1_S2__S2_Test|tests.seqcst.sync.L1_S2__S1__S1__S1_L2_Test|tests.seqcst.sync.L1_S2__S1__S1__S1_S2_Test|tests.seqcst.sync.L1_S2__S1__S1__S2_L1_Test|tests.seqcst.sync.L1_S2__S1__S1__S2_L2_Test|tests.seqcst.sync.L1_S2__S1__S1__S2_S1_Test|tests.seqcst.sync.L1_S2__S1__S1__S2_S2_Test|tests.seqcst.sync.L1_S2__S1__S2_L1_Test|tests.seqcst.sync.L1_S2__S1__S2_L2_Test|tests.seqcst.sync.L1_S2__S1__S2_S1_Test|tests.seqcst.sync.L1_S2__S1__S2_S2_Test|tests.seqcst.sync.L1_S2__S1__S2_Test|tests.seqcst.sync.L1_S2__S1__S2__S2_L1_Test|tests.seqcst.sync.L1_S2__S1__S2__S2_L2_Test|tests.seqcst.sync.L1_S2__S1__S2__S2_S1_Test|tests.seqcst.sync.L1_S2__S1__S2__S2_S2_Test|tests.seqcst.sync.L1_S2__S2_L3__S3_S1_Test|tests.seqcst.sync.L1_S2__S2_S1_Test|tests.seqcst.sync.L1_S2__S2_S3__S3_S1_Test|tests.seqcst.sync.L1_S2__S2__S2_S1_Test|tests.seqcst.sync.L1_S2__S2__S2__S2_S1_Test|tests.seqcst.sync.L1_S2__S3_L2__S3_S1_Test|tests.seqcst.sync.L1_S2__S3_S1__S3_S2_Test|tests.seqcst.sync.L1_S3__S1_L2_L3__S2_Test|tests.seqcst.sync.L1_S3__S1_L2_S3__S2_Test|tests.seqcst.sync.L1_S3__S1_S2_L3__S2_Test|tests.seqcst.sync.L1_S3__S1_S2_S3__S2_Test|tests.seqcst.sync.L2_L1__S1_S2_L3__S3_Test|tests.seqcst.sync.L2_L1__S1_S2_S3__S3_Test|tests.seqcst.sync.L2_L3__S1__S1_S2_S3_Test|tests.seqcst.sync.L2_S1__S1_S2_L3__S3_Test|tests.seqcst.sync.L2_S1__S1_S2_S3__S3_Test|tests.seqcst.sync.L2_S3__S1__S1_S2_L3_Test|tests.seqcst.sync.L2_S3__S1__S1_S2_S3_Test|tests.seqcst.sync.L3_L1__S1_L2_S3__S2_Test|tests.seqcst.sync.L3_L1__S1_S2_S3__S2_Test|tests.seqcst.sync.L3_L2__S1__S1_S2_S3_Test|tests.seqcst.sync.L3_S1__S1_L2_S3__S2_Test|tests.seqcst.sync.L3_S1__S1_S2_S3__S2_Test|tests.seqcst.sync.L3_S2__S1__S1_L2_S3_Test|tests.seqcst.sync.L3_S2__S1__S1_S2_S3_Test|tests.seqcst.sync.S1_L1__S1_L1_Test|tests.seqcst.sync.S1_L1__S1_L1__S2__S2_Test|tests.seqcst.sync.S1_L1__S1_L2__S2_Test|tests.seqcst.sync.S1_L1__S1_L2__S2__S2_Test|tests.seqcst.sync.S1_L1__S1_S1_Test|tests.seqcst.sync.S1_L1__S1_S1__S2__S2_Test|tests.seqcst.sync.S1_L1__S1_S2__S2_Test|tests.seqcst.sync.S1_L1__S1_S2__S2__S2_Test|tests.seqcst.sync.S1_L1__S2__S2_L1_Test|tests.seqcst.sync.S1_L1__S2__S2_S1_Test|tests.seqcst.sync.S1_L1__S2__S2__S2_L1_Test|tests.seqcst.sync.S1_L1__S2__S2__S2_S1_Test|tests.seqcst.sync.S1_L2_L3__S1_S2__S3_Test|tests.seqcst.sync.S1_L2_L3__S1_S3__S2_Test|tests.seqcst.sync.S1_L2_L3__S2_L1__S3_Test|tests.seqcst.sync.S1_L2_L3__S2_S1__S3_Test|tests.seqcst.sync.S1_L2_L3__S2__S3_L1_Test|tests.seqcst.sync.S1_L2_L3__S2__S3_S1_Test|tests.seqcst.sync.S1_L2_S3__S1_L3__S2_Test|tests.seqcst.sync.S1_L2_S3__S1_S2__S3_Test|tests.seqcst.sync.S1_L2_S3__S1_S3__S2_Test|tests.seqcst.sync.S1_L2_S3__S2_L1__S3_Test|tests.seqcst.sync.S1_L2_S3__S2_S1__S3_Test|tests.seqcst.sync.S1_L2_S3__S2__S3_L1_Test|tests.seqcst.sync.S1_L2_S3__S2__S3_S1_Test|tests.seqcst.sync.S1_L2__S1_L2__S2_Test|tests.seqcst.sync.S1_L2__S1_L2__S2__S2_Test|tests.seqcst.sync.S1_L2__S1_L3__S2_S3_Test|tests.seqcst.sync.S1_L2__S1_L3__S3_S2_Test|tests.seqcst.sync.S1_L2__S1_S1__S2_Test|tests.seqcst.sync.S1_L2__S1_S1__S2__S2_Test|tests.seqcst.sync.S1_L2__S1_S2_L3__S3_Test|tests.seqcst.sync.S1_L2__S1_S2_S3__S3_Test|tests.seqcst.sync.S1_L2__S1_S2_Test|tests.seqcst.sync.S1_L2__S1_S2__S2_Test|tests.seqcst.sync.S1_L2__S1_S2__S2__S2_Test|tests.seqcst.sync.S1_L2__S1_S3__S2_L3_Test|tests.seqcst.sync.S1_L2__S1_S3__S2_S3_Test|tests.seqcst.sync.S1_L2__S1_S3__S3_S2_Test|tests.seqcst.sync.S1_L2__S2_L1_Test|tests.seqcst.sync.S1_L2__S2_L3__S3_L1_Test|tests.seqcst.sync.S1_L2__S2_L3__S3_S1_Test|tests.seqcst.sync.S1_L2__S2_S1_Test|tests.seqcst.sync.S1_L2__S2_S3__S3_L1_Test|tests.seqcst.sync.S1_L2__S2_S3__S3_S1_Test|tests.seqcst.sync.S1_L2__S2__S2_L1_Test|tests.seqcst.sync.S1_L2__S2__S2_S1_Test|tests.seqcst.sync.S1_L2__S2__S2__S2_L1_Test|tests.seqcst.sync.S1_L2__S2__S2__S2_S1_Test|tests.seqcst.sync.S1_L2__S3_L1__S3_S2_Test|tests.seqcst.sync.S1_L2__S3_S1__S3_S2_Test|tests.seqcst.sync.S1_L3__S1_S2_S3__S2_Test|tests.seqcst.sync.S1_S1__S1_S1_Test|tests.seqcst.sync.S1_S1__S1_S1__S2__S2_Test|tests.seqcst.sync.S1_S1__S1_S2__S2_Test|tests.seqcst.sync.S1_S1__S1_S2__S2__S2_Test|tests.seqcst.sync.S1_S1__S2__S2_S1_Test|tests.seqcst.sync.S1_S1__S2__S2__S2_S1_Test|tests.seqcst.sync.S1_S2_L3__S1_S3__S2_Test|tests.seqcst.sync.S1_S2_L3__S2_L1__S3_Test|tests.seqcst.sync.S1_S2_L3__S2_S1__S3_Test|tests.seqcst.sync.S1_S2_L3__S2__S3_L1_Test|tests.seqcst.sync.S1_S2_L3__S2__S3_S1_Test|tests.seqcst.sync.S1_S2_S3__S2_L1__S3_Test|tests.seqcst.sync.S1_S2_S3__S2_S1__S3_Test|tests.seqcst.sync.S1_S2_S3__S2__S3_L1_Test|tests.seqcst.sync.S1_S2_S3__S2__S3_S1_Test|tests.seqcst.sync.S1_S2__S1_S2_L3__S3_Test|tests.seqcst.sync.S1_S2__S2_S1_Test|tests.seqcst.sync.S1_S2__S2_S3__S3_S1_Test|tests.seqcst.sync.S1_S2__S2__S2_S1_Test|tests.seqcst.sync.S1_S2__S2__S2__S2_S1_Test|tests.seqcst.sync.S1__S1_L1_L1_Test|tests.seqcst.sync.S1__S1_L1_L1__S2__S2_Test|tests.seqcst.sync.S1__S1_L1_L2__S2_Test|tests.seqcst.sync.S1__S1_L1_L2__S2__S2_Test|tests.seqcst.sync.S1__S1_L1_S1_Test|tests.seqcst.sync.S1__S1_L1_S1__S2__S2_Test|tests.seqcst.sync.S1__S1_L1_S2__S2_Test|tests.seqcst.sync.S1__S1_L1_S2__S2__S2_Test|tests.seqcst.sync.S1__S1_L1_Test|tests.seqcst.sync.S1__S1_L1__S1_L1_Test|tests.seqcst.sync.S1__S1_L1__S1_L2__S2_Test|tests.seqcst.sync.S1__S1_L1__S1_S1_Test|tests.seqcst.sync.S1__S1_L1__S1_S2__S2_Test|tests.seqcst.sync.S1__S1_L1__S2__S2_L1_Test|tests.seqcst.sync.S1__S1_L1__S2__S2_L2_Test|tests.seqcst.sync.S1__S1_L1__S2__S2_S1_Test|tests.seqcst.sync.S1__S1_L1__S2__S2_S2_Test|tests.seqcst.sync.S1__S1_L2_L1__S2_Test|tests.seqcst.sync.S1__S1_L2_L1__S2__S2_Test|tests.seqcst.sync.S1__S1_L2_L2__S2_Test|tests.seqcst.sync.S1__S1_L2_L2__S2__S2_Test|tests.seqcst.sync.S1__S1_L2_L3__S2_S3_Test|tests.seqcst.sync.S1__S1_L2_L3__S3_S2_Test|tests.seqcst.sync.S1__S1_L2_S1__S2_Test|tests.seqcst.sync.S1__S1_L2_S1__S2__S2_Test|tests.seqcst.sync.S1__S1_L2_S2__S2_Test|tests.seqcst.sync.S1__S1_L2_S2__S2__S2_Test|tests.seqcst.sync.S1__S1_L2_S3__S2_L3_Test|tests.seqcst.sync.S1__S1_L2_S3__S2_S3_Test|tests.seqcst.sync.S1__S1_L2_S3__S3_S2_Test|tests.seqcst.sync.S1__S1_L2__S1_L2__S2_Test|tests.seqcst.sync.S1__S1_L2__S1_S1__S2_Test|tests.seqcst.sync.S1__S1_L2__S1_S2_Test|tests.seqcst.sync.S1__S1_L2__S1_S2__S2_Test|tests.seqcst.sync.S1__S1_L2__S2_L1_Test|tests.seqcst.sync.S1__S1_L2__S2_L2_Test|tests.seqcst.sync.S1__S1_L2__S2_S1_Test|tests.seqcst.sync.S1__S1_L2__S2_S2_Test|tests.seqcst.sync.S1__S1_L2__S2_Test|tests.seqcst.sync.S1__S1_L2__S2__S2_L1_Test|tests.seqcst.sync.S1__S1_L2__S2__S2_L2_Test|tests.seqcst.sync.S1__S1_L2__S2__S2_S1_Test|tests.seqcst.sync.S1__S1_L2__S2__S2_S2_Test|tests.seqcst.sync.S1__S1_S1_L1_Test|tests.seqcst.sync.S1__S1_S1_L1__S2__S2_Test|tests.seqcst.sync.S1__S1_S1_L2__S2_Test|tests.seqcst.sync.S1__S1_S1_L2__S2__S2_Test|tests.seqcst.sync.S1__S1_S1_S1_Test|tests.seqcst.sync.S1__S1_S1_S1__S2__S2_Test|tests.seqcst.sync.S1__S1_S1_S2__S2_Test|tests.seqcst.sync.S1__S1_S1_S2__S2__S2_Test|tests.seqcst.sync.S1__S1_S1_Test|tests.seqcst.sync.S1__S1_S1__S1_S1_Test|tests.seqcst.sync.S1__S1_S1__S1_S2__S2_Test|tests.seqcst.sync.S1__S1_S1__S2__S2_S1_Test|tests.seqcst.sync.S1__S1_S1__S2__S2_S2_Test|tests.seqcst.sync.S1__S1_S2_L1__S2_Test|tests.seqcst.sync.S1__S1_S2_L1__S2__S2_Test|tests.seqcst.sync.S1__S1_S2_L2__S2_Test|tests.seqcst.sync.S1__S1_S2_L2__S2__S2_Test|tests.seqcst.sync.S1__S1_S2_L3__S2_S3_Test|tests.seqcst.sync.S1__S1_S2_L3__S3_L2_Test|tests.seqcst.sync.S1__S1_S2_L3__S3_S2_Test|tests.seqcst.sync.S1__S1_S2_S1__S2_Test|tests.seqcst.sync.S1__S1_S2_S1__S2__S2_Test|tests.seqcst.sync.S1__S1_S2_S2__S2_Test|tests.seqcst.sync.S1__S1_S2_S2__S2__S2_Test|tests.seqcst.sync.S1__S1_S2_S3__S2_L3_Test|tests.seqcst.sync.S1__S1_S2_S3__S3_L2_Test|tests.seqcst.sync.S1__S1_S2_S3__S3_S2_Test|tests.seqcst.sync.S1__S1_S2__S2_S1_Test|tests.seqcst.sync.S1__S1_S2__S2_S2_Test|tests.seqcst.sync.S1__S1_S2__S2__S2_S1_Test|tests.seqcst.sync.S1__S1_S2__S2__S2_S2_Test|tests.seqcst.sync.S1__S1__S1_L1_L1_Test|tests.seqcst.sync.S1__S1__S1_L1_L2__S2_Test|tests.seqcst.sync.S1__S1__S1_L1_S1_Test|tests.seqcst.sync.S1__S1__S1_L1_S2__S2_Test|tests.seqcst.sync.S1__S1__S1_L1__S1_L1_Test|tests.seqcst.sync.S1__S1__S1_L1__S1_S1_Test|tests.seqcst.sync.S1__S1__S1_L2_L1__S2_Test|tests.seqcst.sync.S1__S1__S1_L2_L2__S2_Test|tests.seqcst.sync.S1__S1__S1_L2_S1__S2_Test|tests.seqcst.sync.S1__S1__S1_L2_S2__S2_Test|tests.seqcst.sync.S1__S1__S1_L2__S1_S2_Test|tests.seqcst.sync.S1__S1__S1_L2__S2_L1_Test|tests.seqcst.sync.S1__S1__S1_L2__S2_L2_Test|tests.seqcst.sync.S1__S1__S1_L2__S2_S1_Test|tests.seqcst.sync.S1__S1__S1_L2__S2_S2_Test|tests.seqcst.sync.S1__S1__S1_S1_L1_Test|tests.seqcst.sync.S1__S1__S1_S1_L2__S2_Test|tests.seqcst.sync.S1__S1__S1_S1_S1_Test|tests.seqcst.sync.S1__S1__S1_S1_S2__S2_Test|tests.seqcst.sync.S1__S1__S1_S1__S1_S1_Test|tests.seqcst.sync.S1__S1__S1_S2_L1__S2_Test|tests.seqcst.sync.S1__S1__S1_S2_L2__S2_Test|tests.seqcst.sync.S1__S1__S1_S2_S1__S2_Test|tests.seqcst.sync.S1__S1__S1_S2_S2__S2_Test|tests.seqcst.sync.S1__S1__S1_S2__S2_S1_Test|tests.seqcst.sync.S1__S1__S1_S2__S2_S2_Test|tests.seqcst.sync.S1__S1__S1__S1_L1_L1_Test|tests.seqcst.sync.S1__S1__S1__S1_L1_S1_Test|tests.seqcst.sync.S1__S1__S1__S1_S1_L1_Test|tests.seqcst.sync.S1__S1__S1__S1_S1_S1_Test"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+<test>
+	<testCaseName>jcstress.seqcst.volatiles</testCaseName>
+	<!-- 82/82 org.openjdk.jcstress.tests.seqcst.volatiles: classes 489/tests 2131(ac/ar:1642/489)  -->
+                       <disables>
+                     <disable>
+                       <comment>all secondary targets are for manual usage now</comment>
+                     </disable>
+                   </disables>
+       <command>
+         if [ "x$${JC_CORES}" = "x" ] ; then JC_CORES="-c 2" ; else if [ "$${JC_CORES}" -eq "0" ] ; then JC_CORES="" ; else JC_CORES="-c $${JC_CORES}" ;fi;fi;\
+         if [ "x$${JC_TIME_BUDGET}" = "x" ] ; then JC_TIME_BUDGET="-tb 1h" ; else if [ "$${JC_TIME_BUDGET}" -eq "0" ] ; then JC_TIME_BUDGET="" ; else JC_TIME_BUDGET="-tb $${JC_TIME_BUDGET}" ;fi;fi;\
+         if [ "x$${PRINT_INTERVAL_MS}" = "x" ] ; then PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=3600000" ; else PRINT_INTERVAL_MS="-Djcstress.console.printIntervalMs=$${PRINT_INTERVAL_MS}" ;fi;\
+         $(JAVA_COMMAND) $(JVM_OPTIONS) $${PRINT_INTERVAL_MS}} -jar $(Q)$(LIB_DIR)$(D)jcstress-tests-all-20240222.jar$(Q) $(APPLICATION_OPTIONS) $${JC_TIME_BUDGET}  $${JC_CORES} -t "tests.seqcst.volatiles.L1_L1_L1__S1_Test|tests.seqcst.volatiles.L1_L1_L1__S1__S1_Test|tests.seqcst.volatiles.L1_L1_L1__S1__S1__S1_Test|tests.seqcst.volatiles.L1_L1_L1__S1__S2__S2_Test|tests.seqcst.volatiles.L1_L1_L2__S1__S1__S2_Test|tests.seqcst.volatiles.L1_L1_L2__S1__S2_Test|tests.seqcst.volatiles.L1_L1_L2__S1__S2__S2_Test|tests.seqcst.volatiles.L1_L1_S1__S1_Test|tests.seqcst.volatiles.L1_L1_S1__S1__S1_Test|tests.seqcst.volatiles.L1_L1_S1__S1__S1__S1_Test|tests.seqcst.volatiles.L1_L1_S1__S1__S2__S2_Test|tests.seqcst.volatiles.L1_L1_S2__S1__S1__S2_Test|tests.seqcst.volatiles.L1_L1_S2__S1__S2_Test|tests.seqcst.volatiles.L1_L1_S2__S1__S2__S2_Test|tests.seqcst.volatiles.L1_L1__L1_L1__S1_Test|tests.seqcst.volatiles.L1_L1__L1_L1__S1__S1_Test|tests.seqcst.volatiles.L1_L1__L1_L2__S1__S2_Test|tests.seqcst.volatiles.L1_L1__L1_S1_Test|tests.seqcst.volatiles.L1_L1__L1_S1__S1_Test|tests.seqcst.volatiles.L1_L1__L1_S1__S1__S1_Test|tests.seqcst.volatiles.L1_L1__L1_S1__S2__S2_Test|tests.seqcst.volatiles.L1_L1__L1_S2__S1__S2_Test|tests.seqcst.volatiles.L1_L1__L2_L1__S1__S2_Test|tests.seqcst.volatiles.L1_L1__L2_L2__S1__S2_Test|tests.seqcst.volatiles.L1_L1__L2_S1__S1__S2_Test|tests.seqcst.volatiles.L1_L1__L2_S1__S2_Test|tests.seqcst.volatiles.L1_L1__L2_S1__S2__S2_Test|tests.seqcst.volatiles.L1_L1__L2_S2__S1__S2_Test|tests.seqcst.volatiles.L1_L1__S1_L1_Test|tests.seqcst.volatiles.L1_L1__S1_L1__S2__S2_Test|tests.seqcst.volatiles.L1_L1__S1_L2__S2_Test|tests.seqcst.volatiles.L1_L1__S1_L2__S2__S2_Test|tests.seqcst.volatiles.L1_L1__S1_S1_Test|tests.seqcst.volatiles.L1_L1__S1_S1__S2__S2_Test|tests.seqcst.volatiles.L1_L1__S1_S2__S2_Test|tests.seqcst.volatiles.L1_L1__S1_S2__S2__S2_Test|tests.seqcst.volatiles.L1_L1__S1_Test|tests.seqcst.volatiles.L1_L1__S1__S1_L1_Test|tests.seqcst.volatiles.L1_L1__S1__S1_L2__S2_Test|tests.seqcst.volatiles.L1_L1__S1__S1_S1_Test|tests.seqcst.volatiles.L1_L1__S1__S1_S2__S2_Test|tests.seqcst.volatiles.L1_L1__S1__S1__S1_L1_Test|tests.seqcst.volatiles.L1_L1__S1__S1__S1_S1_Test|tests.seqcst.volatiles.L1_L1__S1__S2__S2_L1_Test|tests.seqcst.volatiles.L1_L1__S1__S2__S2_L2_Test|tests.seqcst.volatiles.L1_L1__S1__S2__S2_S1_Test|tests.seqcst.volatiles.L1_L1__S1__S2__S2_S2_Test|tests.seqcst.volatiles.L1_L1__S2__S2_S1_Test|tests.seqcst.volatiles.L1_L1__S2__S2__S2_S1_Test|tests.seqcst.volatiles.L1_L2_L1__S1__S1__S2_Test|tests.seqcst.volatiles.L1_L2_L1__S1__S2_Test|tests.seqcst.volatiles.L1_L2_L1__S1__S2__S2_Test|tests.seqcst.volatiles.L1_L2_L2__S1__S1__S2_Test|tests.seqcst.volatiles.L1_L2_L2__S1__S2_Test|tests.seqcst.volatiles.L1_L2_L2__S1__S2__S2_Test|tests.seqcst.volatiles.L1_L2_L3__S1_S2__S3_Test|tests.seqcst.volatiles.L1_L2_L3__S1_S3__S2_Test|tests.seqcst.volatiles.L1_L2_L3__S1__S2_S3_Test|tests.seqcst.volatiles.L1_L2_L3__S1__S3_S2_Test|tests.seqcst.volatiles.L1_L2_L3__S2_S1__S3_Test|tests.seqcst.volatiles.L1_L2_L3__S2__S3_S1_Test|tests.seqcst.volatiles.L1_L2_S1__S1__S1__S2_Test|tests.seqcst.volatiles.L1_L2_S1__S1__S2_Test|tests.seqcst.volatiles.L1_L2_S1__S1__S2__S2_Test|tests.seqcst.volatiles.L1_L2_S2__S1__S1__S2_Test|tests.seqcst.volatiles.L1_L2_S2__S1__S2_Test|tests.seqcst.volatiles.L1_L2_S2__S1__S2__S2_Test|tests.seqcst.volatiles.L1_L2_S3__L3_S1__S2_Test|tests.seqcst.volatiles.L1_L2_S3__L3_S2__S1_Test|tests.seqcst.volatiles.L1_L2_S3__S1_L3__S2_Test|tests.seqcst.volatiles.L1_L2_S3__S1_S2__S3_Test|tests.seqcst.volatiles.L1_L2_S3__S1_S3__S2_Test|tests.seqcst.volatiles.L1_L2_S3__S1__S2_L3_Test|tests.seqcst.volatiles.L1_L2_S3__S1__S2_S3_Test|tests.seqcst.volatiles.L1_L2_S3__S1__S3_S2_Test|tests.seqcst.volatiles.L1_L2_S3__S2_S1__S3_Test|tests.seqcst.volatiles.L1_L2_S3__S2__S3_S1_Test|tests.seqcst.volatiles.L1_L2__L1_L2__S1__S2_Test|tests.seqcst.volatiles.L1_L2__L1_S1__S1__S2_Test|tests.seqcst.volatiles.L1_L2__L1_S1__S2_Test|tests.seqcst.volatiles.L1_L2__L1_S1__S2__S2_Test|tests.seqcst.volatiles.L1_L2__L1_S2__S1_Test|tests.seqcst.volatiles.L1_L2__L1_S2__S1__S1_Test|tests.seqcst.volatiles.L1_L2__L1_S2__S1__S2_Test|tests.seqcst.volatiles.L1_L2__L2_L1__S1__S2_Test|tests.seqcst.volatiles.L1_L2__L2_L2__S1__S2_Test|tests.seqcst.volatiles.L1_L2__L2_S1__S1__S2_Test|tests.seqcst.volatiles.L1_L2__L2_S1__S2_Test|tests.seqcst.volatiles.L1_L2__L2_S1__S2__S2_Test|tests.seqcst.volatiles.L1_L2__L2_S2__S1_Test|tests.seqcst.volatiles.L1_L2__L2_S2__S1__S1_Test|tests.seqcst.volatiles.L1_L2__L2_S2__S1__S2_Test|tests.seqcst.volatiles.L1_L2__L3_S1__S2_S3_Test|tests.seqcst.volatiles.L1_L2__L3_S1__S3_S2_Test|tests.seqcst.volatiles.L1_L2__L3_S2__S1_S3_Test|tests.seqcst.volatiles.L1_L2__L3_S2__S3_S1_Test|tests.seqcst.volatiles.L1_L2__S1_L1__S2_Test|tests.seqcst.volatiles.L1_L2__S1_L1__S2__S2_Test|tests.seqcst.volatiles.L1_L2__S1_L2__S2_Test|tests.seqcst.volatiles.L1_L2__S1_L2__S2__S2_Test|tests.seqcst.volatiles.L1_L2__S1_L3__S2_S3_Test|tests.seqcst.volatiles.L1_L2__S1_L3__S3_S2_Test|tests.seqcst.volatiles.L1_L2__S1_S1__S2_Test|tests.seqcst.volatiles.L1_L2__S1_S1__S2__S2_Test|tests.seqcst.volatiles.L1_L2__S1_S2_L3__S3_Test|tests.seqcst.volatiles.L1_L2__S1_S2_S3__S3_Test|tests.seqcst.volatiles.L1_L2__S1_S2_Test|tests.seqcst.volatiles.L1_L2__S1_S2__S2_Test|tests.seqcst.volatiles.L1_L2__S1_S2__S2__S2_Test|tests.seqcst.volatiles.L1_L2__S1_S3__S2_L3_Test|tests.seqcst.volatiles.L1_L2__S1_S3__S2_S3_Test|tests.seqcst.volatiles.L1_L2__S1_S3__S3_S2_Test|tests.seqcst.volatiles.L1_L2__S1__S1_L1__S2_Test|tests.seqcst.volatiles.L1_L2__S1__S1_L2__S2_Test|tests.seqcst.volatiles.L1_L2__S1__S1_S1__S2_Test|tests.seqcst.volatiles.L1_L2__S1__S1_S2_Test|tests.seqcst.volatiles.L1_L2__S1__S1_S2__S2_Test|tests.seqcst.volatiles.L1_L2__S1__S1__S1_S2_Test|tests.seqcst.volatiles.L1_L2__S1__S1__S2_L1_Test|tests.seqcst.volatiles.L1_L2__S1__S1__S2_L2_Test|tests.seqcst.volatiles.L1_L2__S1__S1__S2_S1_Test|tests.seqcst.volatiles.L1_L2__S1__S1__S2_S2_Test|tests.seqcst.volatiles.L1_L2__S1__S2_L1_Test|tests.seqcst.volatiles.L1_L2__S1__S2_L2_Test|tests.seqcst.volatiles.L1_L2__S1__S2_S1_Test|tests.seqcst.volatiles.L1_L2__S1__S2_S2_Test|tests.seqcst.volatiles.L1_L2__S1__S2_Test|tests.seqcst.volatiles.L1_L2__S1__S2__S2_L1_Test|tests.seqcst.volatiles.L1_L2__S1__S2__S2_L2_Test|tests.seqcst.volatiles.L1_L2__S1__S2__S2_S1_Test|tests.seqcst.volatiles.L1_L2__S1__S2__S2_S2_Test|tests.seqcst.volatiles.L1_L2__S2_L3__S3_S1_Test|tests.seqcst.volatiles.L1_L2__S2_S1_Test|tests.seqcst.volatiles.L1_L2__S2_S3__S3_S1_Test|tests.seqcst.volatiles.L1_L2__S2__S2_S1_Test|tests.seqcst.volatiles.L1_L2__S2__S2__S2_S1_Test|tests.seqcst.volatiles.L1_L2__S3_S1__S3_S2_Test|tests.seqcst.volatiles.L1_L3__S1_L2_S3__S2_Test|tests.seqcst.volatiles.L1_L3__S1_S2_S3__S2_Test|tests.seqcst.volatiles.L1_S1_L1__S1_Test|tests.seqcst.volatiles.L1_S1_L1__S1__S1_Test|tests.seqcst.volatiles.L1_S1_L1__S1__S1__S1_Test|tests.seqcst.volatiles.L1_S1_L1__S1__S2__S2_Test|tests.seqcst.volatiles.L1_S1_L2__S1__S1__S2_Test|tests.seqcst.volatiles.L1_S1_L2__S1__S2_Test|tests.seqcst.volatiles.L1_S1_L2__S1__S2__S2_Test|tests.seqcst.volatiles.L1_S1_S1__S1_Test|tests.seqcst.volatiles.L1_S1_S1__S1__S1_Test|tests.seqcst.volatiles.L1_S1_S1__S1__S1__S1_Test|tests.seqcst.volatiles.L1_S1_S1__S1__S2__S2_Test|tests.seqcst.volatiles.L1_S1_S2__S1__S1__S2_Test|tests.seqcst.volatiles.L1_S1_S2__S1__S2_Test|tests.seqcst.volatiles.L1_S1_S2__S1__S2__S2_Test|tests.seqcst.volatiles.L1_S1__L1_S1_Test|tests.seqcst.volatiles.L1_S1__L1_S1__S1_Test|tests.seqcst.volatiles.L1_S1__L1_S1__S1__S1_Test|tests.seqcst.volatiles.L1_S1__L1_S1__S2__S2_Test|tests.seqcst.volatiles.L1_S1__L1_S2__S1__S2_Test|tests.seqcst.volatiles.L1_S1__L1_S2__S2_Test|tests.seqcst.volatiles.L1_S1__L1_S2__S2__S2_Test|tests.seqcst.volatiles.L1_S1__L2_S1__S1__S2_Test|tests.seqcst.volatiles.L1_S1__L2_S1__S2_Test|tests.seqcst.volatiles.L1_S1__L2_S1__S2__S2_Test|tests.seqcst.volatiles.L1_S1__L2_S2__S1__S2_Test|tests.seqcst.volatiles.L1_S1__S1_L1_Test|tests.seqcst.volatiles.L1_S1__S1_L1__S2__S2_Test|tests.seqcst.volatiles.L1_S1__S1_L2__S2_Test|tests.seqcst.volatiles.L1_S1__S1_L2__S2__S2_Test|tests.seqcst.volatiles.L1_S1__S1_S1_Test|tests.seqcst.volatiles.L1_S1__S1_S1__S2__S2_Test|tests.seqcst.volatiles.L1_S1__S1_S2__S2_Test|tests.seqcst.volatiles.L1_S1__S1_S2__S2__S2_Test|tests.seqcst.volatiles.L1_S1__S1_Test|tests.seqcst.volatiles.L1_S1__S1__S1_L1_Test|tests.seqcst.volatiles.L1_S1__S1__S1_L2__S2_Test|tests.seqcst.volatiles.L1_S1__S1__S1_S1_Test|tests.seqcst.volatiles.L1_S1__S1__S1_S2__S2_Test|tests.seqcst.volatiles.L1_S1__S1__S1__S1_L1_Test|tests.seqcst.volatiles.L1_S1__S1__S1__S1_S1_Test|tests.seqcst.volatiles.L1_S1__S1__S2__S2_L1_Test|tests.seqcst.volatiles.L1_S1__S1__S2__S2_L2_Test|tests.seqcst.volatiles.L1_S1__S1__S2__S2_S1_Test|tests.seqcst.volatiles.L1_S1__S1__S2__S2_S2_Test|tests.seqcst.volatiles.L1_S1__S2__S2_L1_Test|tests.seqcst.volatiles.L1_S1__S2__S2_S1_Test|tests.seqcst.volatiles.L1_S1__S2__S2__S2_L1_Test|tests.seqcst.volatiles.L1_S1__S2__S2__S2_S1_Test|tests.seqcst.volatiles.L1_S2_L1__S1__S1__S2_Test|tests.seqcst.volatiles.L1_S2_L1__S1__S2_Test|tests.seqcst.volatiles.L1_S2_L1__S1__S2__S2_Test|tests.seqcst.volatiles.L1_S2_L2__S1__S1__S2_Test|tests.seqcst.volatiles.L1_S2_L2__S1__S2_Test|tests.seqcst.volatiles.L1_S2_L2__S1__S2__S2_Test|tests.seqcst.volatiles.L1_S2_L3__L2_S1__S3_Test|tests.seqcst.volatiles.L1_S2_L3__L2_S3__S1_Test|tests.seqcst.volatiles.L1_S2_L3__S1_L2__S3_Test|tests.seqcst.volatiles.L1_S2_L3__S1_S2__S3_Test|tests.seqcst.volatiles.L1_S2_L3__S1_S3__S2_Test|tests.seqcst.volatiles.L1_S2_L3__S1__S2_S3_Test|tests.seqcst.volatiles.L1_S2_L3__S1__S3_L2_Test|tests.seqcst.volatiles.L1_S2_L3__S1__S3_S2_Test|tests.seqcst.volatiles.L1_S2_L3__S2_S1__S3_Test|tests.seqcst.volatiles.L1_S2_L3__S2__S3_S1_Test|tests.seqcst.volatiles.L1_S2_S1__S1__S1__S2_Test|tests.seqcst.volatiles.L1_S2_S1__S1__S2_Test|tests.seqcst.volatiles.L1_S2_S1__S1__S2__S2_Test|tests.seqcst.volatiles.L1_S2_S2__S1__S1__S2_Test|tests.seqcst.volatiles.L1_S2_S2__S1__S2_Test|tests.seqcst.volatiles.L1_S2_S2__S1__S2__S2_Test|tests.seqcst.volatiles.L1_S2_S3__L2_L3__S1_Test|tests.seqcst.volatiles.L1_S2_S3__L2_S1__S3_Test|tests.seqcst.volatiles.L1_S2_S3__L2_S3__S1_Test|tests.seqcst.volatiles.L1_S2_S3__L3_L2__S1_Test|tests.seqcst.volatiles.L1_S2_S3__L3_S1__S2_Test|tests.seqcst.volatiles.L1_S2_S3__L3_S2__S1_Test|tests.seqcst.volatiles.L1_S2_S3__S1_L2__S3_Test|tests.seqcst.volatiles.L1_S2_S3__S1_L3__S2_Test|tests.seqcst.volatiles.L1_S2_S3__S1_S2__S3_Test|tests.seqcst.volatiles.L1_S2_S3__S1_S3__S2_Test|tests.seqcst.volatiles.L1_S2_S3__S1__S2_L3_Test|tests.seqcst.volatiles.L1_S2_S3__S1__S2_S3_Test|tests.seqcst.volatiles.L1_S2_S3__S1__S3_L2_Test|tests.seqcst.volatiles.L1_S2_S3__S1__S3_S2_Test|tests.seqcst.volatiles.L1_S2_S3__S2_S1__S3_Test|tests.seqcst.volatiles.L1_S2_S3__S2__S3_S1_Test|tests.seqcst.volatiles.L1_S2__L1_S2__S1_Test|tests.seqcst.volatiles.L1_S2__L1_S2__S1__S1_Test|tests.seqcst.volatiles.L1_S2__L1_S2__S1__S2_Test|tests.seqcst.volatiles.L1_S2__L2_S1_Test|tests.seqcst.volatiles.L1_S2__L2_S1__S1_Test|tests.seqcst.volatiles.L1_S2__L2_S1__S1__S1_Test|tests.seqcst.volatiles.L1_S2__L2_S1__S1__S2_Test|tests.seqcst.volatiles.L1_S2__L2_S1__S2_Test|tests.seqcst.volatiles.L1_S2__L2_S1__S2__S2_Test|tests.seqcst.volatiles.L1_S2__L2_S2__S1_Test|tests.seqcst.volatiles.L1_S2__L2_S2__S1__S1_Test|tests.seqcst.volatiles.L1_S2__L2_S2__S1__S2_Test|tests.seqcst.volatiles.L1_S2__L2_S3__L3_S1_Test|tests.seqcst.volatiles.L1_S2__L2_S3__S1_L3_Test|tests.seqcst.volatiles.L1_S2__L2_S3__S1_S3_Test|tests.seqcst.volatiles.L1_S2__L2_S3__S3_S1_Test|tests.seqcst.volatiles.L1_S2__L3_S1__S2_S3_Test|tests.seqcst.volatiles.L1_S2__L3_S1__S3_L2_Test|tests.seqcst.volatiles.L1_S2__L3_S1__S3_S2_Test|tests.seqcst.volatiles.L1_S2__L3_S2__S1_S3_Test|tests.seqcst.volatiles.L1_S2__L3_S2__S3_S1_Test|tests.seqcst.volatiles.L1_S2__S1_L1__S2_Test|tests.seqcst.volatiles.L1_S2__S1_L1__S2__S2_Test|tests.seqcst.volatiles.L1_S2__S1_L2_L3__S3_Test|tests.seqcst.volatiles.L1_S2__S1_L2_S3__S3_Test|tests.seqcst.volatiles.L1_S2__S1_L2_Test|tests.seqcst.volatiles.L1_S2__S1_L2__S2_Test|tests.seqcst.volatiles.L1_S2__S1_L2__S2__S2_Test|tests.seqcst.volatiles.L1_S2__S1_L3__S2_S3_Test|tests.seqcst.volatiles.L1_S2__S1_L3__S3_L2_Test|tests.seqcst.volatiles.L1_S2__S1_L3__S3_S2_Test|tests.seqcst.volatiles.L1_S2__S1_S1__S2_Test|tests.seqcst.volatiles.L1_S2__S1_S1__S2__S2_Test|tests.seqcst.volatiles.L1_S2__S1_S2_L3__S3_Test|tests.seqcst.volatiles.L1_S2__S1_S2_S3__S3_Test|tests.seqcst.volatiles.L1_S2__S1_S2_Test|tests.seqcst.volatiles.L1_S2__S1_S2__S2_Test|tests.seqcst.volatiles.L1_S2__S1_S2__S2__S2_Test|tests.seqcst.volatiles.L1_S2__S1_S3__S2_L3_Test|tests.seqcst.volatiles.L1_S2__S1_S3__S2_S3_Test|tests.seqcst.volatiles.L1_S2__S1_S3__S3_L2_Test|tests.seqcst.volatiles.L1_S2__S1_S3__S3_S2_Test|tests.seqcst.volatiles.L1_S2__S1__S1_L1__S2_Test|tests.seqcst.volatiles.L1_S2__S1__S1_L2_Test|tests.seqcst.volatiles.L1_S2__S1__S1_L2__S2_Test|tests.seqcst.volatiles.L1_S2__S1__S1_S1__S2_Test|tests.seqcst.volatiles.L1_S2__S1__S1_S2_Test|tests.seqcst.volatiles.L1_S2__S1__S1_S2__S2_Test|tests.seqcst.volatiles.L1_S2__S1__S1__S1_L2_Test|tests.seqcst.volatiles.L1_S2__S1__S1__S1_S2_Test|tests.seqcst.volatiles.L1_S2__S1__S1__S2_L1_Test|tests.seqcst.volatiles.L1_S2__S1__S1__S2_L2_Test|tests.seqcst.volatiles.L1_S2__S1__S1__S2_S1_Test|tests.seqcst.volatiles.L1_S2__S1__S1__S2_S2_Test|tests.seqcst.volatiles.L1_S2__S1__S2_L1_Test|tests.seqcst.volatiles.L1_S2__S1__S2_L2_Test|tests.seqcst.volatiles.L1_S2__S1__S2_S1_Test|tests.seqcst.volatiles.L1_S2__S1__S2_S2_Test|tests.seqcst.volatiles.L1_S2__S1__S2_Test|tests.seqcst.volatiles.L1_S2__S1__S2__S2_L1_Test|tests.seqcst.volatiles.L1_S2__S1__S2__S2_L2_Test|tests.seqcst.volatiles.L1_S2__S1__S2__S2_S1_Test|tests.seqcst.volatiles.L1_S2__S1__S2__S2_S2_Test|tests.seqcst.volatiles.L1_S2__S2_L3__S3_S1_Test|tests.seqcst.volatiles.L1_S2__S2_S1_Test|tests.seqcst.volatiles.L1_S2__S2_S3__S3_S1_Test|tests.seqcst.volatiles.L1_S2__S2__S2_S1_Test|tests.seqcst.volatiles.L1_S2__S2__S2__S2_S1_Test|tests.seqcst.volatiles.L1_S2__S3_L2__S3_S1_Test|tests.seqcst.volatiles.L1_S2__S3_S1__S3_S2_Test|tests.seqcst.volatiles.L1_S3__S1_L2_L3__S2_Test|tests.seqcst.volatiles.L1_S3__S1_L2_S3__S2_Test|tests.seqcst.volatiles.L1_S3__S1_S2_L3__S2_Test|tests.seqcst.volatiles.L1_S3__S1_S2_S3__S2_Test|tests.seqcst.volatiles.L2_L1__S1_S2_L3__S3_Test|tests.seqcst.volatiles.L2_L1__S1_S2_S3__S3_Test|tests.seqcst.volatiles.L2_L3__S1__S1_S2_S3_Test|tests.seqcst.volatiles.L2_S1__S1_S2_L3__S3_Test|tests.seqcst.volatiles.L2_S1__S1_S2_S3__S3_Test|tests.seqcst.volatiles.L2_S3__S1__S1_S2_L3_Test|tests.seqcst.volatiles.L2_S3__S1__S1_S2_S3_Test|tests.seqcst.volatiles.L3_L1__S1_L2_S3__S2_Test|tests.seqcst.volatiles.L3_L1__S1_S2_S3__S2_Test|tests.seqcst.volatiles.L3_L2__S1__S1_S2_S3_Test|tests.seqcst.volatiles.L3_S1__S1_L2_S3__S2_Test|tests.seqcst.volatiles.L3_S1__S1_S2_S3__S2_Test|tests.seqcst.volatiles.L3_S2__S1__S1_L2_S3_Test|tests.seqcst.volatiles.L3_S2__S1__S1_S2_S3_Test|tests.seqcst.volatiles.S1_L1__S1_L1_Test|tests.seqcst.volatiles.S1_L1__S1_L1__S2__S2_Test|tests.seqcst.volatiles.S1_L1__S1_L2__S2_Test|tests.seqcst.volatiles.S1_L1__S1_L2__S2__S2_Test|tests.seqcst.volatiles.S1_L1__S1_S1_Test|tests.seqcst.volatiles.S1_L1__S1_S1__S2__S2_Test|tests.seqcst.volatiles.S1_L1__S1_S2__S2_Test|tests.seqcst.volatiles.S1_L1__S1_S2__S2__S2_Test|tests.seqcst.volatiles.S1_L1__S2__S2_L1_Test|tests.seqcst.volatiles.S1_L1__S2__S2_S1_Test|tests.seqcst.volatiles.S1_L1__S2__S2__S2_L1_Test|tests.seqcst.volatiles.S1_L1__S2__S2__S2_S1_Test|tests.seqcst.volatiles.S1_L2_L3__S1_S2__S3_Test|tests.seqcst.volatiles.S1_L2_L3__S1_S3__S2_Test|tests.seqcst.volatiles.S1_L2_L3__S2_L1__S3_Test|tests.seqcst.volatiles.S1_L2_L3__S2_S1__S3_Test|tests.seqcst.volatiles.S1_L2_L3__S2__S3_L1_Test|tests.seqcst.volatiles.S1_L2_L3__S2__S3_S1_Test|tests.seqcst.volatiles.S1_L2_S3__S1_L3__S2_Test|tests.seqcst.volatiles.S1_L2_S3__S1_S2__S3_Test|tests.seqcst.volatiles.S1_L2_S3__S1_S3__S2_Test|tests.seqcst.volatiles.S1_L2_S3__S2_L1__S3_Test|tests.seqcst.volatiles.S1_L2_S3__S2_S1__S3_Test|tests.seqcst.volatiles.S1_L2_S3__S2__S3_L1_Test|tests.seqcst.volatiles.S1_L2_S3__S2__S3_S1_Test|tests.seqcst.volatiles.S1_L2__S1_L2__S2_Test|tests.seqcst.volatiles.S1_L2__S1_L2__S2__S2_Test|tests.seqcst.volatiles.S1_L2__S1_L3__S2_S3_Test|tests.seqcst.volatiles.S1_L2__S1_L3__S3_S2_Test|tests.seqcst.volatiles.S1_L2__S1_S1__S2_Test|tests.seqcst.volatiles.S1_L2__S1_S1__S2__S2_Test|tests.seqcst.volatiles.S1_L2__S1_S2_L3__S3_Test|tests.seqcst.volatiles.S1_L2__S1_S2_S3__S3_Test|tests.seqcst.volatiles.S1_L2__S1_S2_Test|tests.seqcst.volatiles.S1_L2__S1_S2__S2_Test|tests.seqcst.volatiles.S1_L2__S1_S2__S2__S2_Test|tests.seqcst.volatiles.S1_L2__S1_S3__S2_L3_Test|tests.seqcst.volatiles.S1_L2__S1_S3__S2_S3_Test|tests.seqcst.volatiles.S1_L2__S1_S3__S3_S2_Test|tests.seqcst.volatiles.S1_L2__S2_L1_Test|tests.seqcst.volatiles.S1_L2__S2_L3__S3_L1_Test|tests.seqcst.volatiles.S1_L2__S2_L3__S3_S1_Test|tests.seqcst.volatiles.S1_L2__S2_S1_Test|tests.seqcst.volatiles.S1_L2__S2_S3__S3_L1_Test|tests.seqcst.volatiles.S1_L2__S2_S3__S3_S1_Test|tests.seqcst.volatiles.S1_L2__S2__S2_L1_Test|tests.seqcst.volatiles.S1_L2__S2__S2_S1_Test|tests.seqcst.volatiles.S1_L2__S2__S2__S2_L1_Test|tests.seqcst.volatiles.S1_L2__S2__S2__S2_S1_Test|tests.seqcst.volatiles.S1_L2__S3_L1__S3_S2_Test|tests.seqcst.volatiles.S1_L2__S3_S1__S3_S2_Test|tests.seqcst.volatiles.S1_L3__S1_S2_S3__S2_Test|tests.seqcst.volatiles.S1_S1__S1_S1_Test|tests.seqcst.volatiles.S1_S1__S1_S1__S2__S2_Test|tests.seqcst.volatiles.S1_S1__S1_S2__S2_Test|tests.seqcst.volatiles.S1_S1__S1_S2__S2__S2_Test|tests.seqcst.volatiles.S1_S1__S2__S2_S1_Test|tests.seqcst.volatiles.S1_S1__S2__S2__S2_S1_Test|tests.seqcst.volatiles.S1_S2_L3__S1_S3__S2_Test|tests.seqcst.volatiles.S1_S2_L3__S2_L1__S3_Test|tests.seqcst.volatiles.S1_S2_L3__S2_S1__S3_Test|tests.seqcst.volatiles.S1_S2_L3__S2__S3_L1_Test|tests.seqcst.volatiles.S1_S2_L3__S2__S3_S1_Test|tests.seqcst.volatiles.S1_S2_S3__S2_L1__S3_Test|tests.seqcst.volatiles.S1_S2_S3__S2_S1__S3_Test|tests.seqcst.volatiles.S1_S2_S3__S2__S3_L1_Test|tests.seqcst.volatiles.S1_S2_S3__S2__S3_S1_Test|tests.seqcst.volatiles.S1_S2__S1_S2_L3__S3_Test|tests.seqcst.volatiles.S1_S2__S2_S1_Test|tests.seqcst.volatiles.S1_S2__S2_S3__S3_S1_Test|tests.seqcst.volatiles.S1_S2__S2__S2_S1_Test|tests.seqcst.volatiles.S1_S2__S2__S2__S2_S1_Test|tests.seqcst.volatiles.S1__S1_L1_L1_Test|tests.seqcst.volatiles.S1__S1_L1_L1__S2__S2_Test|tests.seqcst.volatiles.S1__S1_L1_L2__S2_Test|tests.seqcst.volatiles.S1__S1_L1_L2__S2__S2_Test|tests.seqcst.volatiles.S1__S1_L1_S1_Test|tests.seqcst.volatiles.S1__S1_L1_S1__S2__S2_Test|tests.seqcst.volatiles.S1__S1_L1_S2__S2_Test|tests.seqcst.volatiles.S1__S1_L1_S2__S2__S2_Test|tests.seqcst.volatiles.S1__S1_L1_Test|tests.seqcst.volatiles.S1__S1_L1__S1_L1_Test|tests.seqcst.volatiles.S1__S1_L1__S1_L2__S2_Test|tests.seqcst.volatiles.S1__S1_L1__S1_S1_Test|tests.seqcst.volatiles.S1__S1_L1__S1_S2__S2_Test|tests.seqcst.volatiles.S1__S1_L1__S2__S2_L1_Test|tests.seqcst.volatiles.S1__S1_L1__S2__S2_L2_Test|tests.seqcst.volatiles.S1__S1_L1__S2__S2_S1_Test|tests.seqcst.volatiles.S1__S1_L1__S2__S2_S2_Test|tests.seqcst.volatiles.S1__S1_L2_L1__S2_Test|tests.seqcst.volatiles.S1__S1_L2_L1__S2__S2_Test|tests.seqcst.volatiles.S1__S1_L2_L2__S2_Test|tests.seqcst.volatiles.S1__S1_L2_L2__S2__S2_Test|tests.seqcst.volatiles.S1__S1_L2_L3__S2_S3_Test|tests.seqcst.volatiles.S1__S1_L2_L3__S3_S2_Test|tests.seqcst.volatiles.S1__S1_L2_S1__S2_Test|tests.seqcst.volatiles.S1__S1_L2_S1__S2__S2_Test|tests.seqcst.volatiles.S1__S1_L2_S2__S2_Test|tests.seqcst.volatiles.S1__S1_L2_S2__S2__S2_Test|tests.seqcst.volatiles.S1__S1_L2_S3__S2_L3_Test|tests.seqcst.volatiles.S1__S1_L2_S3__S2_S3_Test|tests.seqcst.volatiles.S1__S1_L2_S3__S3_S2_Test|tests.seqcst.volatiles.S1__S1_L2__S1_L2__S2_Test|tests.seqcst.volatiles.S1__S1_L2__S1_S1__S2_Test|tests.seqcst.volatiles.S1__S1_L2__S1_S2_Test|tests.seqcst.volatiles.S1__S1_L2__S1_S2__S2_Test|tests.seqcst.volatiles.S1__S1_L2__S2_L1_Test|tests.seqcst.volatiles.S1__S1_L2__S2_L2_Test|tests.seqcst.volatiles.S1__S1_L2__S2_S1_Test|tests.seqcst.volatiles.S1__S1_L2__S2_S2_Test|tests.seqcst.volatiles.S1__S1_L2__S2_Test|tests.seqcst.volatiles.S1__S1_L2__S2__S2_L1_Test|tests.seqcst.volatiles.S1__S1_L2__S2__S2_L2_Test|tests.seqcst.volatiles.S1__S1_L2__S2__S2_S1_Test|tests.seqcst.volatiles.S1__S1_L2__S2__S2_S2_Test|tests.seqcst.volatiles.S1__S1_S1_L1_Test|tests.seqcst.volatiles.S1__S1_S1_L1__S2__S2_Test|tests.seqcst.volatiles.S1__S1_S1_L2__S2_Test|tests.seqcst.volatiles.S1__S1_S1_L2__S2__S2_Test|tests.seqcst.volatiles.S1__S1_S1_S1_Test|tests.seqcst.volatiles.S1__S1_S1_S1__S2__S2_Test|tests.seqcst.volatiles.S1__S1_S1_S2__S2_Test|tests.seqcst.volatiles.S1__S1_S1_S2__S2__S2_Test|tests.seqcst.volatiles.S1__S1_S1_Test|tests.seqcst.volatiles.S1__S1_S1__S1_S1_Test|tests.seqcst.volatiles.S1__S1_S1__S1_S2__S2_Test|tests.seqcst.volatiles.S1__S1_S1__S2__S2_S1_Test|tests.seqcst.volatiles.S1__S1_S1__S2__S2_S2_Test|tests.seqcst.volatiles.S1__S1_S2_L1__S2_Test|tests.seqcst.volatiles.S1__S1_S2_L1__S2__S2_Test|tests.seqcst.volatiles.S1__S1_S2_L2__S2_Test|tests.seqcst.volatiles.S1__S1_S2_L2__S2__S2_Test|tests.seqcst.volatiles.S1__S1_S2_L3__S2_S3_Test|tests.seqcst.volatiles.S1__S1_S2_L3__S3_L2_Test|tests.seqcst.volatiles.S1__S1_S2_L3__S3_S2_Test|tests.seqcst.volatiles.S1__S1_S2_S1__S2_Test|tests.seqcst.volatiles.S1__S1_S2_S1__S2__S2_Test|tests.seqcst.volatiles.S1__S1_S2_S2__S2_Test|tests.seqcst.volatiles.S1__S1_S2_S2__S2__S2_Test|tests.seqcst.volatiles.S1__S1_S2_S3__S2_L3_Test|tests.seqcst.volatiles.S1__S1_S2_S3__S3_L2_Test|tests.seqcst.volatiles.S1__S1_S2_S3__S3_S2_Test|tests.seqcst.volatiles.S1__S1_S2__S2_S1_Test|tests.seqcst.volatiles.S1__S1_S2__S2_S2_Test|tests.seqcst.volatiles.S1__S1_S2__S2__S2_S1_Test|tests.seqcst.volatiles.S1__S1_S2__S2__S2_S2_Test|tests.seqcst.volatiles.S1__S1__S1_L1_L1_Test|tests.seqcst.volatiles.S1__S1__S1_L1_L2__S2_Test|tests.seqcst.volatiles.S1__S1__S1_L1_S1_Test|tests.seqcst.volatiles.S1__S1__S1_L1_S2__S2_Test|tests.seqcst.volatiles.S1__S1__S1_L1__S1_L1_Test|tests.seqcst.volatiles.S1__S1__S1_L1__S1_S1_Test|tests.seqcst.volatiles.S1__S1__S1_L2_L1__S2_Test|tests.seqcst.volatiles.S1__S1__S1_L2_L2__S2_Test|tests.seqcst.volatiles.S1__S1__S1_L2_S1__S2_Test|tests.seqcst.volatiles.S1__S1__S1_L2_S2__S2_Test|tests.seqcst.volatiles.S1__S1__S1_L2__S1_S2_Test|tests.seqcst.volatiles.S1__S1__S1_L2__S2_L1_Test|tests.seqcst.volatiles.S1__S1__S1_L2__S2_L2_Test|tests.seqcst.volatiles.S1__S1__S1_L2__S2_S1_Test|tests.seqcst.volatiles.S1__S1__S1_L2__S2_S2_Test|tests.seqcst.volatiles.S1__S1__S1_S1_L1_Test|tests.seqcst.volatiles.S1__S1__S1_S1_L2__S2_Test|tests.seqcst.volatiles.S1__S1__S1_S1_S1_Test|tests.seqcst.volatiles.S1__S1__S1_S1_S2__S2_Test|tests.seqcst.volatiles.S1__S1__S1_S1__S1_S1_Test|tests.seqcst.volatiles.S1__S1__S1_S2_L1__S2_Test|tests.seqcst.volatiles.S1__S1__S1_S2_L2__S2_Test|tests.seqcst.volatiles.S1__S1__S1_S2_S1__S2_Test|tests.seqcst.volatiles.S1__S1__S1_S2_S2__S2_Test|tests.seqcst.volatiles.S1__S1__S1_S2__S2_S1_Test|tests.seqcst.volatiles.S1__S1__S1_S2__S2_S2_Test|tests.seqcst.volatiles.S1__S1__S1__S1_L1_L1_Test|tests.seqcst.volatiles.S1__S1__S1__S1_L1_S1_Test|tests.seqcst.volatiles.S1__S1__S1__S1_S1_L1_Test|tests.seqcst.volatiles.S1__S1__S1__S1_S1_S1_Test"; \
+         $(TEST_STATUS)
+       </command>
+	<levels>
+		<level>dev</level>
+	</levels>
+	<groups>
+		<group>system</group>
+	</groups>
+</test>
+</playlist>