from enum import Enum
import numpy as np


def embeding(data, embed_size):
    result = []
    for X in data:
        tmp = np.array([np.concatenate([x, [0] * (embed_size - len(x))]) if len(x) < embed_size else x for x in X])
        result.append(tmp)
    return result


def normalization_array(data):
    max_num = -1e10
    min_num = 1e10
    for line in data:
        max_num = max(max_num, max(line))
        min_num = min(min_num, min(line))
    # print(max_num,min_num)
    out = []
    for line in data:
        temp = [(x - min_num) / (max_num - min_num) for x in line]
        out.append(temp)
    return out, max_num, min_num


def normalization_seq(data):
    max_num = -1e10
    min_num = 1e10
    for line in data:
        for word in line:
            max_num = max(max_num, max(word))
            min_num = min(min_num, min(word))
    words = []
    out = []
    for line in data:
        words = []
        for word in line:
            temp = [(x - min_num) / (max_num - min_num) for x in word]
            words.append(temp)
        out.append(words)
    return out


def padding_array(X, max_len, padding=0):
    return np.array([np.concatenate([x, [padding] * (max_len - len(x))]) if len(x) < max_len else x for x in X])


def padding_sequence(X, max_len, embed_size, padding=0):
    return np.array(
        [np.concatenate([x, [[padding] * embed_size] * (max_len - len(x))]) if len(x) < max_len else x for x in X])


def return_before(dataSet, max_num, min_num):
    out = []
    out = np.round(dataSet * (max_num - min_num) + min_num)
    '''for line in dataSet:
        temp = [round(x * (max_num - min_num)) + min_num for x in line]
        out.append(temp)'''
    return out


def load_array(filename):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            words = line.split()
            data = [float(x) for x in words]
            dataSet.append(data)
            line = f.readline()

    # normalization
    dataSet, Max, Min = normalization_array(dataSet)
    # padding
    max_len = max(len(x) for x in dataSet)
    dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], -1)
    return dataSet, seq_len, Max, Min


def load_array_split(filename, spliter):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            words = line.strip().split(spliter)
            data = [float(x) if len(x) > 0 else 0 for x in words]

            dataSet.append(data)
            line = f.readline()

    # normalization
    dataSet, Max, Min = normalization_array(dataSet)
    # padding
    max_len = max(len(x) for x in dataSet)
    dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], -1)
    return dataSet, seq_len, Max, Min


def load_sequence(filename):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline().strip()
        while line:
            data = [ord(x) for x in list(line)]
            dataSet.append(data)
            line = f.readline().strip()

    # normalization
    dataSet, Max, Min = normalization_array(dataSet)

    # padding
    max_len = max(len(x) for x in dataSet)
    dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], max_len)
    return dataSet, seq_len, Max, Min


def load_sequence_split(filename, spliter):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline().strip()
        lst = line.split(spliter)
        line = ' '.join(lst)
        while line:
            data = [ord(x) for x in list(line)]
            dataSet.append(data)
            line = f.readline().strip()

    # normalization
    dataSet, Max, Min = normalization_array(dataSet)

    # padding
    max_len = max(len(x) for x in dataSet)
    dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], max_len)
    return dataSet, seq_len, Max, Min


def load_label(filename):
    labelSet = []
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            arr = line.split()
            label = [int(x) for x in arr]
            labelSet.append(label)
            line = f.readline()
    labelSet = np.array(labelSet)
    labelSet = labelSet.reshape(labelSet.shape[0], 1)
    return labelSet


def normalization_dimention(dataSet):
    maxs = np.max(dataSet, axis=0)
    mins = np.min(dataSet, axis=0)
    out = []
    for line in dataSet:
        temp = []
        for j in range(len(line)):
            if maxs[j] == mins[j]:
                num = (line[j] - mins[j]) / 1
            else:
                num = (line[j] - mins[j]) / (maxs[j] - mins[j])
            temp.append(num)
        out.append(temp)
    return out, maxs, mins


def load_before_time14(filename):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            data = []
            words = line.split('#')
            data.append(int(words[0]))
            nums = words[1].split('-')
            for x in nums:
                if x != '':
                    data.append(int(x))
            dataSet.append(data)
            line = f.readline()

    # normalization
    # dataSet = normalization_dimention(dataSet)
    dataSet, Max, Min = normalization_array(dataSet)
    # padding
    max_len = max(len(x) for x in dataSet)
    # dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], max_len)
    return dataSet, seq_len, Max, Min


def load_after_time14(filename):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            data = []
            nums = line.split('-')
            for x in nums:
                if x != '':
                    data.append(int(x))
            dataSet.append(data)
            line = f.readline()

    # normalization
    # dataSet = normalization_dimention(dataSet)
    dataSet, Max, Min = normalization_array(dataSet)
    # padding
    max_len = max(len(x) for x in dataSet)
    # dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], max_len)
    return dataSet, seq_len, Max, Min


def load_data_time3(filename):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            words = line.split('#')
            data = [int(x) for x in words]
            dataSet.append(data)
            line = f.readline()

    # normalization
    dataSet, Maxs, Mins = normalization_dimention(dataSet)
    # padding
    max_len = max(len(x) for x in dataSet)
    dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], max_len)
    return dataSet, seq_len, Maxs, Mins


def load_data_mockito6(filename):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            words = line.split()
            if words[0] != 'null':
                data = [int(x) for x in words]
            else:
                for word in words:
                    data = [ord(x) for x in list(word)]
            dataSet.append(data)
            line = f.readline()

    # normalization
    dataSet, Max, Min = normalization_array(dataSet)
    # padding
    max_len = max(len(x) for x in dataSet)
    dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], -1)
    return dataSet, seq_len, Max, Min


def load_data_math15(filename):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            words = line.split()
            if words[0] != 'Infinity':
                data = [float(x) for x in words]
            else:
                data = [0]
            dataSet.append(data)
            line = f.readline()

    # normalization
    dataSet, Max, Min = normalization_array(dataSet)
    # padding
    max_len = max(len(x) for x in dataSet)
    dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], -1)
    return dataSet, seq_len, Max, Min


def load_data_exp_time7(filename):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            words = line.split()
            data = [float(word) for word in words]
            dataSet.append(data)
            line = f.readline()

    # normalization
    dataSet, Max, Min = normalization_array(dataSet)
    # padding
    max_len = max(len(x) for x in dataSet)
    dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], -1)
    return dataSet, seq_len, Max, Min


def load_data_compress40(filename):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            words = line.split('#')
            lst = words[0].split()
            data = [int(x) for x in lst]
            data.append(int(words[1]))
            dataSet.append(data)
            line = f.readline()

    # normalization
    dataSet, Max, Min = normalization_array(dataSet)
    # padding
    max_len = max(len(x) for x in dataSet)
    dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], max_len)
    return dataSet, seq_len, Max, Min


def load_classification(filename):
    dataSet = []
    with open(filename, 'r') as f:
        line = f.readline()
        while line:
            data = []
            if line == 'true\n':
                data.append(1)
            else:
                data.append(0)
            dataSet.append(data)
            line = f.readline()
    # normalization
    dataSet, Max, Min = normalization_array(dataSet)

    # padding
    max_len = max(len(x) for x in dataSet)
    dataSet = padding_array(dataSet, max_len)
    # mask
    seq_len = [len(x) for x in dataSet]
    dataSet = np.array(dataSet)
    dataSet = dataSet.reshape(dataSet.shape[0], max_len)
    return dataSet, seq_len, Max, Min


def load_M1_before(filename):
    X, seq_len_X, max_x, min_x = load_sequence(filename)
    return X, seq_len_X, max_x, min_x


def load_M1_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M2_before(filename):
    X, seq_len_X, max_x, min_x = load_array(filename)
    return X, seq_len_X, max_x, min_x


def load_M2_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M3_before(filename):
    X, seq_len_X, max_x, min_x = load_sequence(filename)
    return X, seq_len_X, max_x, min_x


def load_M3_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M4_before(filename):
    X, seq_len_X, max_x, min_x = load_data_time3(filename)
    return X, seq_len_X, max_x, min_x


def load_M4_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M5_before(filename):
    X, seq_len_X, max_x, min_x = load_data_time3(filename)
    return X, seq_len_X, max_x, min_x


def load_M5_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M6_before(filename):
    X, seq_len_X, max_x, min_x = load_data_time3(filename)
    return X, seq_len_X, max_x, min_x


def load_M6_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M7_before(filename):
    X, seq_len_X, max_x, min_x = load_data_time3(filename)
    return X, seq_len_X, max_x, min_x


def load_M7_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M8_before(filename):
    X, seq_len_X, max_x, min_x = load_data_time3(filename)
    return X, seq_len_X, max_x, min_x


def load_M8_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M9_before(filename):
    X, seq_len_X, max_x, min_x = load_before_time14(filename)
    return X, seq_len_X, max_x, min_x


def load_M9_after(filename):
    Y, seq_len_Y, max_y, min_y = load_after_time14(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M10_before(filename):
    X, seq_len_X, max_x, min_x = load_before_time14(filename)
    return X, seq_len_X, max_x, min_x


def load_M10_after(filename):
    Y, seq_len_Y, max_y, min_y = load_after_time14(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M11_before(filename):
    X, seq_len_X, max_x, min_x = load_sequence(filename)
    return X, seq_len_X, max_x, min_x


def load_M11_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M12_before(filename):
    X, seq_len_X, max_x, min_x = load_array(filename)
    return X, seq_len_X, max_x, min_x


def load_M12_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M13_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M13_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M14_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M14_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M15_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M15_after(filename):
    Y, seq_len_Y, max_y, min_y = load_classification(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M16_before(filename):
    X, seq_len_X, max_x, min_x = load_sequence(filename)
    return X, seq_len_X, max_x, min_x


def load_M16_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M17_before(filename):
    X, seq_len_X, max_x, min_x = load_data_mockito6(filename)
    return X, seq_len_X, max_x, min_x


def load_M17_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M18_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M18_after(filename):
    Y, seq_len_Y, max_y, min_y = load_classification(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M19_before(filename):
    X, seq_len_X, max_x, min_x = load_data_math15(filename)
    return X, seq_len_X, max_x, min_x


def load_M19_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M20_before(filename):
    X, seq_len_X, max_x, min_x = load_sequence(filename)
    return X, seq_len_X, max_x, min_x


def load_M20_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M21_before(filename):
    X, seq_len_X, max_x, min_x = load_sequence(filename)
    return X, seq_len_X, max_x, min_x


def load_M21_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M22_before(filename):
    X, seq_len_X, max_x, min_x = load_data_compress40(filename)
    return X, seq_len_X, max_x, min_x


def load_M22_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M23_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence(filename)
    return Y, seq_len_Y, max_y, min_y


def load_M23_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_Exp_time7_before(filename):
    Y, seq_len_Y, max_y, min_y = load_data_exp_time7(filename)
    return Y, seq_len_Y, max_y, min_y


def load_Exp_time7_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array(filename)
    return Y, seq_len_Y, max_y, min_y


def load_compare_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_compare_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_getSignificand_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_getSignificand_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_getPackageName_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_getPackageName_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_firstCharOnlyToUpper_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_firstCharOnlyToUpper_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_repeat_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_repeat_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_integerToRoman_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_integerToRoman_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_convert_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_convert_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_decimalToHex_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_decimalToHex_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_ascToBcd_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_ascToBcd_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_absVal_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_absVal_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_sumOfDigits_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_sumOfDigits_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isFormatLetter_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isFormatLetter_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isPalindrome_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isPalindrome_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_toUpperCase_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_toUpperCase_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isValidPort_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isValidPort_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isInner_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isInner_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isHexChar_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isHexChar_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_getStart_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_getStart_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_getEndByStart_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_getEndByStart_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_reverseWithSwaps_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_reverseWithSwaps_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_reverseWithXOR_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_reverseWithXOR_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isDigit_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isDigit_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_next_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_next_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_previous_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_previous_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_before_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_before_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isOutOfBounds_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isOutOfBounds_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_patch_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_patch_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_chars_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_chars_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_lowerFirst_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_lowerFirst_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_swapCase_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_swapCase_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_formatNumber_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_formatNumber_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_formatEscapeCharsForListing_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_formatEscapeCharsForListing_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_checkPositive_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_checkPositive_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_checkPositiveOrZero_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_checkPositiveOrZero_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_checkLessThan_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_checkLessThan_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_ceil_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_ceil_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_floor_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_floor_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_max_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_max_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_strToBcd_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_strToBcd_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isOneByte_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isOneByte_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isTwoBytes_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isTwoBytes_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isNotTrailingByte_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isNotTrailingByte_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_trailingByteValue_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_trailingByteValue_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_CommonResult_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_CommonResult_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_validateFailed_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_validateFailed_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_failed_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_failed_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_escapeTags_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_escapeTags_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_addText_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_addText_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_slashify_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_slashify_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_setPattern_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_setPattern_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isTextual_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isTextual_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_add_flink_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_add_flink_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_merge_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_merge_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_reduce_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_reduce_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_getAgeType_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_getAgeType_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_of_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_of_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_error_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_error_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_ProductCategory_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_ProductCategory_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_CartDTO_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_CartDTO_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_min_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_min_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_maxOfKnowledge_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_maxOfKnowledge_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_count_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_count_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_trimUni_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_trimUni_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_stripIsbnSeparator_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_stripIsbnSeparator_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_toASCII_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_toASCII_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_trimRegexSlashes_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_trimRegexSlashes_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_rCnt_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_rCnt_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_mCnt_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_mCnt_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_escapeEncode_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_escapeEncode_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_escapeDecode_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_escapeDecode_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_makeUniqueKey_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_makeUniqueKey_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_append_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_append_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_prepend_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_prepend_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_enclose_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_enclose_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_encode_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_encode_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_unquote_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_unquote_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_unescape_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_unescape_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_determinePath_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_determinePath_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_determinePort_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_determinePort_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_Address_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_Address_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_increment_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_increment_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_setUserInfo_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_setUserInfo_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_ProxyHandshaker_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_ProxyHandshaker_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isDotDirective_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isDotDirective_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_calculateDigits_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_calculateDigits_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_calculateDigitSum_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_calculateDigitSum_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_toOpcodeName_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_toOpcodeName_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_parseMaxWindowBits_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_parseMaxWindowBits_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_createFixedSizeStripedCounterV6_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_createFixedSizeStripedCounterV6_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_createFixedSizeStripedCounterV8_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_createFixedSizeStripedCounterV8_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_longValue_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_longValue_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_add_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_add_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_set_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_set_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_PaddedAtomicLong_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_PaddedAtomicLong_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_requirePositive_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_requirePositive_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_requireInRange_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_requireInRange_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_requireNegative_before(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_requireNegative_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_lowerCase_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_lowerCase_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isWord_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isWord_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isAlphabetical_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isAlphabetical_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isLowerCase_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isLowerCase_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_reverse_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_reverse_after(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isUpperCase_before(filename):
    Y, seq_len_Y, max_y, min_y = load_sequence_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


def load_isUpperCase_after(filename):
    Y, seq_len_Y, max_y, min_y = load_array_split(filename, '$')
    return Y, seq_len_Y, max_y, min_y


before_func = {
    # TM
    'jacksoncore_6': load_M1_before,
    'compress_30': load_M2_before,
    'csv_14': load_M3_before,
    'time_3_addYears': load_M4_before,
    'time_3_addMonths': load_M5_before,
    'time_3_addWeeks': load_M6_before,
    'time_3_addDays': load_M7_before,
    'time_3_add': load_M8_before,
    'time_14_minusMonths': load_M9_before,
    'time_14_plusMonths': load_M10_before,
    'csv_3': load_M11_before,
    'lang_21': load_M12_before,
    'io_18': load_M13_before,
    'shiro_web_3': load_M14_before,
    'johnzon_core_2': load_M15_before,
    'compress_39': load_M16_before,
    'mockito_6': load_M17_before,
    'geometry_core_3': load_M18_before,
    'math_15': load_M19_before,
    'codec_15': load_M20_before,
    'codec_3': load_M21_before,
    'compress_40': load_M22_before,
    'io_25': load_M23_before,
    # MM
    'getPackageName': load_getPackageName_before,
    'getSignificand': load_getSignificand_before,
    'firstCharOnlyToUpper': load_firstCharOnlyToUpper_before,
    'compare': load_compare_before,
    'repeat': load_repeat_before,
    'integerToRoman': load_integerToRoman_before,
    'convert': load_convert_before,
    'decimalToHex': load_decimalToHex_before,
    'absVal': load_absVal_before,
    'sumOfDigits': load_sumOfDigits_before,
    'isPalindrome': load_isPalindrome_before,
    'toUpperCase': load_toUpperCase_before,
    'isAlphabetical': load_isAlphabetical_before,
    'ceil': load_ceil_before,
    'floor': load_floor_before,
    'max': load_max_before,
    'strToBcd': load_strToBcd_before,
    'ascToBcd': load_ascToBcd_before,
    'isFormatLetter': load_isFormatLetter_before,
    'isValidPort': load_isValidPort_before,
    'isInner': load_isInner_before,
    'isHexChar': load_isHexChar_before,
    'getStart': load_getStart_before,
    'getEndByStart': load_getEndByStart_before,
    'reverseWithSwaps': load_reverseWithSwaps_before,
    'reverseWithXOR': load_reverseWithXOR_before,
    'isDigit': load_isDigit_before,
    'next': load_next_before,
    'previous': load_previous_before,
    'isOutOfBounds': load_isOutOfBounds_before,
    'patch': load_patch_before,
    'chars': load_chars_before,
    'isUpperCase': load_isUpperCase_before,
    'isLowerCase': load_isLowerCase_before,
    'reverse': load_reverse_before,
    'lowerFirst': load_lowerFirst_before,
    'swapCase': load_swapCase_before,
    'formatNumber': load_formatNumber_before,
    'formatEscapeCharsForListing': load_formatEscapeCharsForListing_before,
    'checkPositive': load_checkPositive_before,
    'checkPositiveOrZero': load_checkPositiveOrZero_before,
    'checkLessThan': load_checkLessThan_before,
    'createFixedSizeStripedCounterV6': load_createFixedSizeStripedCounterV6_before,
    'createFixedSizeStripedCounterV8': load_createFixedSizeStripedCounterV8_before,
    'longValue': load_longValue_before,
    'add': load_add_before,
    'set': load_set_before,
    'PaddedAtomicLong': load_PaddedAtomicLong_before,
    'requirePositive': load_requirePositive_before,
    'requireInRange': load_requireInRange_before,
    'requireNegative': load_requireNegative_before,
    'lowerCase': load_lowerCase_before,
    'isWord': load_isWord_before,
    'isOneByte': load_isOneByte_before,
    'isTwoBytes': load_isTwoBytes_before,
    'isNotTrailingByte': load_isNotTrailingByte_before,
    'trailingByteValue': load_trailingByteValue_before,
    'CommonResult': load_CommonResult_before,
    'validateFailed': load_validateFailed_before,
    'failed': load_failed_before,
    'escapeTags': load_escapeTags_before,
    'addText': load_addText_before,
    'slashify': load_slashify_before,
    'setPattern': load_setPattern_before,
    'isTextual': load_isTextual_before,
    'add_flink': load_add_flink_before,
    'merge': load_merge_before,
    'reduce': load_reduce_before,
    'getAgeType': load_getAgeType_before,
    'of': load_of_before,
    'error': load_error_before,
    'ProductCategory': load_ProductCategory_before,
    'CartDTO': load_CartDTO_before,
    'min': load_min_before,
    'maxOfKnowledge': load_maxOfKnowledge_before,
    'count': load_count_before,
    'trimUni': load_trimUni_before,
    'stripIsbnSeparator': load_stripIsbnSeparator_before,
    'toASCII': load_toASCII_before,
    'trimRegexSlashes': load_trimRegexSlashes_before,
    'rCnt': load_rCnt_before,
    'mCnt': load_mCnt_before,
    'escapeEncode': load_escapeEncode_before,
    'escapeDecode': load_escapeDecode_before,
    'makeUniqueKey': load_makeUniqueKey_before,
    'append': load_append_before,
    'encode': load_encode_before,
    'unquote': load_unquote_before,
    'unescape': load_unescape_before,
    'determinePath': load_determinePath_before,
    'determinePort': load_determinePort_before,
    'Address': load_Address_before,
    'increment': load_increment_before,
    'setUserInfo': load_setUserInfo_before,
    'ProxyHandshaker': load_ProxyHandshaker_before,
    'isDotDirective': load_isDotDirective_before,
    'calculateDigits': load_calculateDigits_before,
    'calculateDigitSum': load_calculateDigitSum_before,
    'toOpcodeName': load_toOpcodeName_before,
    'parseMaxWindowBits': load_parseMaxWindowBits_before
}
after_func = {
    # TM
    'jacksoncore_6': load_M1_after,
    'compress_30': load_M2_after,
    'csv_14': load_M3_after,
    'time_3_addYears': load_M4_after,
    'time_3_addMonths': load_M5_after,
    'time_3_addWeeks': load_M6_after,
    'time_3_addDays': load_M7_after,
    'time_3_add': load_M8_after,
    'time_14_minusMonths': load_M9_after,
    'time_14_plusMonths': load_M10_after,
    'csv_3': load_M11_after,
    'lang_21': load_M12_after,
    'io_18': load_M13_after,
    'shiro_web_3': load_M14_after,
    'johnzon_core_2': load_M15_after,
    'compress_39': load_M16_after,
    'mockito_6': load_M17_after,
    'geometry_core_3': load_M18_after,
    'math_15': load_M19_after,
    'codec_15': load_M20_after,
    'codec_3': load_M21_after,
    'compress_40': load_M22_after,
    'io_25': load_M23_after,
    # MM
    'getPackageName': load_getPackageName_after,
    'getSignificand': load_getSignificand_after,
    'firstCharOnlyToUpper': load_firstCharOnlyToUpper_after,
    'compare': load_compare_after,
    'repeat': load_repeat_after,
    'integerToRoman': load_integerToRoman_after,
    'convert': load_convert_after,
    'decimalToHex': load_decimalToHex_after,
    'absVal': load_absVal_after,
    'sumOfDigits': load_sumOfDigits_after,
    'isPalindrome': load_isPalindrome_after,
    'toUpperCase': load_toUpperCase_after,
    'isAlphabetical': load_isAlphabetical_after,
    'ceil': load_ceil_after,
    'floor': load_floor_after,
    'max': load_max_after,
    'strToBcd': load_strToBcd_after,
    'ascToBcd': load_ascToBcd_after,
    'isValidPort': load_isValidPort_after,
    'isFormatLetter': load_isFormatLetter_after,
    'isInner': load_isInner_after,
    'isHexChar': load_isHexChar_after,
    'getStart': load_getStart_after,
    'getEndByStart': load_getEndByStart_after,
    'reverseWithSwaps': load_reverseWithSwaps_after,
    'reverseWithXOR': load_reverseWithXOR_after,
    'isDigit': load_isDigit_after,
    'next': load_next_after,
    'previous': load_previous_after,
    'isOutOfBounds': load_isOutOfBounds_after,
    'patch': load_patch_after,
    'chars': load_chars_after,
    'isUpperCase': load_isUpperCase_after,
    'isLowerCase': load_isLowerCase_after,
    'reverse': load_reverse_after,
    'lowerFirst': load_lowerFirst_after,
    'swapCase': load_swapCase_after,
    'formatNumber': load_formatNumber_after,
    'formatEscapeCharsForListing': load_formatEscapeCharsForListing_after,
    'checkPositive': load_checkPositive_after,
    'checkPositiveOrZero': load_checkPositiveOrZero_after,
    'checkLessThan': load_checkLessThan_after,
    'createFixedSizeStripedCounterV6': load_createFixedSizeStripedCounterV6_after,
    'createFixedSizeStripedCounterV8': load_createFixedSizeStripedCounterV8_after,
    'longValue': load_longValue_after,
    'add': load_add_after,
    'set': load_set_after,
    'PaddedAtomicLong': load_PaddedAtomicLong_after,
    'requirePositive': load_requirePositive_after,
    'requireInRange': load_requireInRange_after,
    'requireNegative': load_requireNegative_after,
    'lowerCase': load_lowerCase_after,
    'isWord': load_isWord_after,
    'isOneByte': load_isOneByte_after,
    'isTwoBytes': load_isTwoBytes_after,
    'isNotTrailingByte': load_isNotTrailingByte_after,
    'trailingByteValue': load_trailingByteValue_after,
    'CommonResult': load_CommonResult_after,
    'validateFailed': load_validateFailed_after,
    'failed': load_failed_after,
    'escapeTags': load_escapeTags_after,
    'addText': load_addText_after,
    'slashify': load_slashify_after,
    'setPattern': load_setPattern_after,
    'isTextual': load_isTextual_after,
    'add_flink': load_add_flink_after,
    'merge': load_merge_after,
    'reduce': load_reduce_after,
    'getAgeType': load_getAgeType_after,
    'of': load_of_after,
    'error': load_error_after,
    'ProductCategory': load_ProductCategory_after,
    'CartDTO': load_CartDTO_after,
    'min': load_min_after,
    'maxOfKnowledge': load_maxOfKnowledge_after,
    'count': load_count_after,
    'trimUni': load_trimUni_after,
    'stripIsbnSeparator': load_stripIsbnSeparator_after,
    'toASCII': load_toASCII_after,
    'trimRegexSlashes': load_trimRegexSlashes_after,
    'rCnt': load_rCnt_after,
    'mCnt': load_mCnt_after,
    'escapeEncode': load_escapeEncode_after,
    'escapeDecode': load_escapeDecode_after,
    'makeUniqueKey': load_makeUniqueKey_after,
    'append': load_append_after,
    'encode': load_encode_after,
    'unquote': load_unquote_after,
    'unescape': load_unescape_after,
    'determinePath': load_determinePath_after,
    'determinePort': load_determinePort_after,
    'Address': load_Address_after,
    'increment': load_increment_after,
    'setUserInfo': load_setUserInfo_after,
    'ProxyHandshaker': load_ProxyHandshaker_after,
    'isDotDirective': load_isDotDirective_after,
    'calculateDigits': load_calculateDigits_after,
    'calculateDigitSum': load_calculateDigitSum_after,
    'toOpcodeName': load_toOpcodeName_after,
    'parseMaxWindowBits': load_parseMaxWindowBits_after
}
