// Path: src/tools/containers/CircularArrayList.java
// public class CircularArrayList<E> extends ArrayList<E> {
// 
//     /**
//      * Overriding of the get method
//      * @param index Index for the access
//      * @return Corresponding value
//      */
//     public E get(int index) {
//         while (index < 0)
//             index += size();
//         index %= size();
//         return super.get(index);
//     }
// }
// 
// Path: src/main/options/ExecutionParameters.java
// public class ExecutionParameters {
//     /**
//      * Specify if the verbose mode is activated
//      */
//     public static boolean verbose = false;
// 
//     /**
//      * Specify if we train the program (if we fill and save the Markov chains)
//      */
//     public static boolean train = false;
// 
//     /**
//      * Specify the seed for generation
//      */
//     public static int seed = 3657263;
// 
//     /**
//      * Specify the path to the training set (for writing or reading)
//      */
//     public static Path LSTMTrainingSetPath = Paths.get("assets/abc");
// 
//     /**
//      * Specify the path to the trained data (created after training and used for generation)
//      */
//     public static Path trainedLSTMPath = Paths.get("assets/training/trained-lstm");
// }


import tools.containers.CircularArrayList;
import jm.constants.Pitches;
import main.options.ExecutionParameters;
import java.util.ArrayList;
            if (n != null && n >= 0)
                chordsize++;

        // Compute the matching percentage for each possible degree
        for (int i = 0; i < chords_.size(); ++i) {
            for (int j = 0; j < chord.size(); ++j) {
                if (chord.get(j) == null || chord.get(j) < 0)
                    continue;
                for (int k = 0; k < chords_.get(i).length - 1; ++k) {
                    if (chords_.get(i)[k] % 12 == chord.get(j) % 12) {
                        percentage[i] += 1.0;
                        break;
                    }
                }
            }
            percentage[i] /= chordsize;
        }

        double max = 0.0;
        int degree = 0;

        // Find the degree with the best matching percentage
        for (int i = 0; i < percentage.length; ++i) {
            if (percentage[i] > max) {
                max = percentage[i];
                degree = i + 1;
            }
        }

        boolean seventhChord = false;
// Path: src/tools/containers/CircularArrayList.java
// public class CircularArrayList<E> extends ArrayList<E> {
// 
//     /**
//      * Overriding of the get method
//      * @param index Index for the access
//      * @return Corresponding value
//      */
//     public E get(int index) {
//         while (index < 0)
//             index += size();
//         index %= size();
//         return super.get(index);
//     }
// }
// 
// Path: src/main/options/ExecutionParameters.java
// public class ExecutionParameters {
//     /**
//      * Specify if the verbose mode is activated
//      */
//     public static boolean verbose = false;
// 
//     /**
//      * Specify if we train the program (if we fill and save the Markov chains)
//      */
//     public static boolean train = false;
// 
//     /**
//      * Specify the seed for generation
//      */
//     public static int seed = 3657263;
// 
//     /**
//      * Specify the path to the training set (for writing or reading)
//      */
//     public static Path LSTMTrainingSetPath = Paths.get("assets/abc");
// 
//     /**
//      * Specify the path to the trained data (created after training and used for generation)
//      */
//     public static Path trainedLSTMPath = Paths.get("assets/training/trained-lstm");
// }


// Path: src/analysis/harmonic/ChordDegreeComputer.java
import tools.containers.CircularArrayList;
import jm.constants.Pitches;
import main.options.ExecutionParameters;
import java.util.ArrayList;

            if (n != null && n >= 0)
                chordsize++;

        // Compute the matching percentage for each possible degree
        for (int i = 0; i < chords_.size(); ++i) {
            for (int j = 0; j < chord.size(); ++j) {
                if (chord.get(j) == null || chord.get(j) < 0)
                    continue;
                for (int k = 0; k < chords_.get(i).length - 1; ++k) {
                    if (chords_.get(i)[k] % 12 == chord.get(j) % 12) {
                        percentage[i] += 1.0;
                        break;
                    }
                }
            }
            percentage[i] /= chordsize;
        }

        double max = 0.0;
        int degree = 0;

        // Find the degree with the best matching percentage
        for (int i = 0; i < percentage.length; ++i) {
            if (percentage[i] > max) {
                max = percentage[i];
                degree = i + 1;
            }
        }

        boolean seventhChord = false;
        double seventhPercentage = 0.0;