include "globals.mzn";

int : n_intervals;
int : n_operations;
int : n_locations;
int : n_moving_obj;

array [1..n_operations, 0..(n_intervals + 1)] of var bool : op_status;
array [1..n_operations, 0..(n_intervals + 1)] of var bool : op_start;

array [1..n_moving_obj, 1..n_operations] of bool : moving_op_of_obj;

% Определение current_moving_operation.
    % Текущая операция операция перемещения, в которой задействован данный объект.
    array [1..n_moving_obj, 0..(n_intervals + 1)] of var 0..n_operations : current_moving_operation;

    % Крайние значения.
    constraint forall (obj in 1..n_moving_obj, t in {0, n_intervals + 1}) (
        current_moving_operation[obj, t] = 0
    );

    % Текущая операция лежит в множестве тех, которые затрагивают данный объект.
    constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
        (current_moving_operation[obj, t] != 0) -> moving_op_of_obj[obj, current_moving_operation[obj, t]]
    );
    % Если операция, затрагивающая данный объект в качестве главного, выполняется - то именно она текущая операция перемещения для этого объекта.
    constraint forall (op in 1..n_operations, t in 1..n_intervals where is_moving_operation[op]) (
        op_status[op, t] -> (current_moving_operation[main_obj_of_operation[op], t] = op)
    );
    % Связь current_moving_operation c op_status.
    constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
        (current_moving_operation[obj, t] != 0) -> (op_status[current_moving_operation[obj, t], t])
    );

% Ограничение на количество пришвартованных кораблей.
    % Счётчик объектов в локации (только в чётных - в состоянии пришвартованности).
    array [1..n_locations, 0..(n_intervals + 1)] of var int : obj_in_loc_counter;

    array [1..n_locations] of 1..n_locations : twin_location = [i - 1 + (i mod 2) * 2 | i in 1..n_locations];

    % Операции грузообработки, проводимые без пришвартовки на этой локации.
    array [1..n_locations] of set of 1..n_operations : related_unmoored_cargo_op;

    % Определение obj_in_loc_counter.
    constraint forall (loc in 1..n_locations, t in 0..n_intervals where (loc mod 2) = 0) (
        obj_in_loc_counter[loc, t] = (sum (obj in 1..n_moving_obj) (m_obj_loc[obj, t + 1] = loc)) % Швартовка и нахождение у причала.
                                   + (sum (op in related_unmoored_cargo_op[twin_location[loc]]) (op_status[op, t])) % Погрузка без швартовки.
                                  % + (sum (op in 1..n_operations where ((not is_moving_operation[op]) /\ (main_obj_start_loc[op] = twin_location[loc]))) % Погрузка без швартовки.
                                  %      (op_status[op, t])
                                  %   ) % TODO узнать, почему медленнее варианта выше.
                                   + (sum (op in 1..n_operations where (is_mooring_op[op] /\ (main_obj_start_loc[op] = loc))) % Отшвартовка.
                                        (op_status[op, t])
                                     )
    );

    % Само ограничение.
    constraint forall (loc in 1..n_locations, t in 0..(n_intervals + 1) where (loc mod 2) = 0) (
        obj_in_loc_counter[loc, t] <= 1
    );

% Определение is_m_obj_in_movement_before_start.
    % Находится ли объект в движении перед началом интервала.
    array [1..n_moving_obj, 0..(n_intervals + 1)] of var bool : is_m_obj_in_movement_before_start;

    % В начале никто не движется.
    constraint forall (obj in 1..n_moving_obj) (not is_m_obj_in_movement_before_start[obj, 0]);
    % Перед первым интервалом все тоже стоят на месте.
    constraint forall (obj in 1..n_moving_obj) (not is_m_obj_in_movement_before_start[obj, 1]);

    % Если в предыдущем интервале объект не движется - то в начале этого он не движется, иначе он движется если предыдущая операция не закончилась.
        constraint forall (obj in 1..n_moving_obj, t in 1..(n_intervals + 1)) (
            (current_moving_operation[obj, t - 1] = 0)
                -> is_m_obj_in_movement_before_start[obj, t] = false
        );
        constraint forall (obj in 1..n_moving_obj, t in 1..(n_intervals + 1)) (
            (current_moving_operation[obj, t - 1] != 0)
                -> is_m_obj_in_movement_before_start[obj, t] = (current_moving_operation[obj, t - 1] == current_moving_operation[obj, t])
        );

array [1..n_operations] of 1..n_locations : operations_destination; % Локация в которой окажется объект после завершения операции.

% Определение m_obj_loc.
    % Местоположение объекта или пункт назначения (если объект движется) перед началом определённого интервала.
    array [1..n_moving_obj, 0..(n_intervals + 1)] of var 1..n_locations : m_obj_loc;

    % Главный объект (субъект) операции.
    array [0..n_operations] of 1..n_moving_obj : main_obj_of_operation;

    % Является ли операция швартовкой/отшвартовкой.
    array [0..n_operations] of bool : is_mooring_op;

    % За фиктивный нулевой интервал объект не успевает ничего сделать с начальным положением.
    constraint forall (obj in 1..n_moving_obj) (
        m_obj_loc[obj, 1] = m_obj_loc[obj, 0]
    );

    % Направление движения/местоположение объекта может измениться только если перед этим началась операция перемещения, и он не вспомогательный при операции швартовки.
        constraint forall (obj in 1..n_moving_obj, t in 2..(n_intervals + 1)) (
            ((current_moving_operation[obj, t - 1] != current_moving_operation[obj, t - 2]) /\
             (current_moving_operation[obj, t - 1] != 0) /\
             ((obj = main_obj_of_operation[current_moving_operation[obj, t - 1]])
                  \/
              (not is_mooring_op[current_moving_operation[obj, t - 1]])
             )
            ) -> (m_obj_loc[obj, t] = operations_destination[current_moving_operation[obj, t - 1]])
        );
        constraint forall (obj in 1..n_moving_obj, t in 2..(n_intervals + 1)) (
            ((current_moving_operation[obj, t - 1] = current_moving_operation[obj, t - 2]) \/
             (current_moving_operation[obj, t - 1] = 0) \/
             ((obj != main_obj_of_operation[current_moving_operation[obj, t - 1]])
                  /\
              (    is_mooring_op[current_moving_operation[obj, t - 1]])
             )
            ) -> (m_obj_loc[obj, t] = m_obj_loc[obj, t - 1])
        );

% Начальное состояние.
    array [1..n_moving_obj] of 0..n_locations : initial_m_obj_loc;
    constraint forall (i in 1..n_moving_obj) (m_obj_loc[i, 0] = initial_m_obj_loc[i]);

% Конечное состояние.
    array [1..n_moving_obj] of 0..n_locations : final_m_obj_loc;
    constraint forall (i in 1..n_moving_obj) (
        (final_m_obj_loc[i] != 0) ->
            (m_obj_loc[i, n_intervals + 1] = final_m_obj_loc[i])
    );

% Определение op_status, op_start.
    constraint forall (i in 1..n_operations, j in {0, n_intervals + 1}) (op_status[i, j] == 0); % Краевые значения.

    constraint forall (op in 1..n_operations, j in {0, n_intervals + 1}) (op_start[op, j] = false);
    constraint forall (i in 1..n_operations, j in 1..(n_intervals + 1)) (op_start[i, j] = (op_status[i, j] /\ not op_status[i, j - 1]));

% Связь ресурсов с операцией и основным объектом.
    % Операции, которые могут задействовать данный объект как ресурс.
    array [1..n_moving_obj] of set of 1..n_operations : operations_that_used_obj_as_resource;

    % Является ли данная операция операцией перемещения.
    array [0..n_operations] of bool : is_moving_operation;

    % Операция, в которой участвует данный объект как ресурс.
    array [1..n_moving_obj, 0..(n_intervals + 1)] of var 0..n_operations : participation_as_resource;

        % Граничные значения.
        constraint forall (obj in 1..n_moving_obj) (participation_as_resource[obj, 0] = 0);
        constraint forall (obj in 1..n_moving_obj) (participation_as_resource[obj, n_intervals + 1] = 0);

        % Только те операции, которые затрагивают данный объект.
        constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
            (participation_as_resource[obj, t] != 0)
                -> participation_as_resource[obj, t] in operations_that_used_obj_as_resource[obj]
        );

        % Связь с текущими операциями перемещения.
            % Если объект задействован в операции перемещения, которая использует его как ресурс,
            % то participation_as_resource должен указывать на эту операцию.
            constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
                 (current_moving_operation[obj, t] in operations_that_used_obj_as_resource[obj])
                    ->
                 (participation_as_resource[obj, t] = current_moving_operation[obj, t])
            );
            % Если объект участвует как ресурс в операции перемещения, то это согласованно с current_moving_operation.
            constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
                ((participation_as_resource[obj, t] != 0) /\
                 (is_moving_operation[participation_as_resource[obj, t]])
                ) -> (participation_as_resource[obj, t] = current_moving_operation[obj, t])
            );

        % { Объект участвует где-то в качестве ресурса - соответствующая операция обязана быть активной. }
        constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
            (participation_as_resource[obj, t] != 0) -> op_status[participation_as_resource[obj, t], t]
        );

        % От начала операции и до конца её ресурсы не могут измениться (в том числе и для погрузки).
        constraint forall (obj in 1..n_moving_obj, t in 1..(n_intervals - 1)) (
            ((participation_as_resource[obj, t] != 0) /\
             (op_status[participation_as_resource[obj, t], t + 1])
            ) -> (participation_as_resource[obj, t + 1] = participation_as_resource[obj, t])
        );

    int : n_resources_types; % Количество различных типов ресурсов.
    array [1..n_resources_types] of set of 1..n_moving_obj : objects_of_type; % Все объекты конкретного типа.

    int : n_resources_counters; % Количество счётчиков ресурсов.
    % Счётчик ресурсов.
    array [1..n_resources_counters , 1..n_intervals] of var int : resources_counter;
    array [1..n_resources_counters] of 1..n_resources_types : counter_type; % Типы ресурсов, за которыми следят счётчики.
    array [1..n_resources_counters] of 1..n_operations : operation_of_counter; % Операция, которой принадлежит данный счётчик.
    array [1..n_resources_counters] of int : required_counter_values; % Необходимые значения на счётчиках ресурсов для выполнения операции.
    array [1..n_operations] of set of 1..n_resources_counters : counters_of_operation; % Счётчики, которые относятся к данной операции.

    % Участие всех необходимых ресурсов в операции.
    constraint forall (t in 1..n_intervals, op in 1..n_operations, counter in counters_of_operation[op]) (
        op_status[op, t] -> (resources_counter[counter, t] = required_counter_values[counter])
    );

    % Определение resources_counter.
    constraint forall (counter in 1..n_resources_counters, t in 1..n_intervals) (
        resources_counter[counter, t] = sum (obj in objects_of_type[counter_type[counter]]) (
            participation_as_resource[obj, t] = operation_of_counter[counter]
        )
    );

% Участие объекта в операциях грузообработки.
    array [1..n_moving_obj, 1..n_intervals] of var bool : is_involved_in_cargo_op;

    array [1..n_moving_obj] of set of 1..n_operations : related_cargo_op_using_obj_as_main;

    % TODO узнать про where
    % Определение is_involved_in_cargo_op.
    constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
        is_involved_in_cargo_op[obj, t] =
            % (exists (op in 1..n_operations where (not is_moving_operation[op]) /\ (main_obj_of_operation[op] = obj)) (
            (exists (op in related_cargo_op_using_obj_as_main[obj]) (
                 op_status[op, t]
            ))
                \/
            ((participation_as_resource[obj, t] != 0) /\ (not is_moving_operation[participation_as_resource[obj, t]]))
    );
    % Операции перемещения исключают операции грузообработки и наоборот.
    constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
        is_involved_in_cargo_op[obj, t] -> (current_moving_operation[obj, t] = 0)
    );

% Наличие всех объектов на месте во время начала операции перемещения + готовность к началу.
    % Требуемое положение конкретных типов объектов в момент начала операций.
    array [1..n_resources_counters] of 1..n_locations : operations_resources_start_loc;

    % Требуемое положение главного объекта в момент начала операций.
    array [1..n_operations] of 1..n_locations : main_obj_start_loc;

    % Наличие и готовность всех ресурсов.
    constraint forall (
        op      in 1..n_operations,
        t       in 1..n_intervals,
        counter in counters_of_operation[op],
        obj     in objects_of_type[counter_type[counter]]) (
            ((participation_as_resource[obj, t] = op) /\ (op_start[op, t])
            ) -> ((m_obj_loc[obj, t] == operations_resources_start_loc[counter]) /\
                  (not is_m_obj_in_movement_before_start[obj, t]) /\
                  ((not is_moving_operation[op]) -> (current_moving_operation[obj, t] = 0))
                 )
    );
    /* TODO узнать, как ((not is_moving_operation[op]) -> (current_moving_operation[obj, t] = 0)) влияет на производительность -
        по идее это не нужно, но на v2-60 без неё гораздо лучше чем с ней.
    */

    % Наличие главных объектов (субъектов) на месте.
    constraint forall (op in 1..n_operations, t in 1..n_intervals, obj = main_obj_of_operation[op]) (
        op_start[op, t] -> ((m_obj_loc[obj, t] == main_obj_start_loc[op]) /\
                            (not is_m_obj_in_movement_before_start[obj, t])
                           )
    );

% Непрерывность перемещения и швартовки.
    array [1..n_operations] of int : operations_duration;
    array [1..n_operations] of bool : is_continuous_operation;

    constraint forall (i in 1..n_operations, len = operations_duration[i] where is_continuous_operation[i]) (
        (forall (j in 1..(n_intervals - len + 1)) (
            (op_start[i, j] == 1) -> (
                (forall (k in 1..(len - 1)) (op_status[i, j + k]))
                    /\
                (not op_status[i, j + len])
            )
        )) /\
        (forall (j in (n_intervals - len + 2)..(n_intervals + 1)) (op_start[i, j] == false))
    );

% Конфликтующие операции.
    array [1..n_operations] of set of 1..n_operations : conflicting_operations;

        constraint forall (op in 1..n_operations, t in 0..(n_intervals + 1), conf_op in conflicting_operations[op]) (
            op_status[op, t] -> not op_status[conf_op, t]
        );

% Окна непогоды.
    array [1..n_operations, 1..n_intervals] of bool : bad_weather;

    constraint forall (op in 1..n_operations, t in 1..n_intervals) (
        bad_weather[op, t] -> (op_status[op, t] = false)
    );

% Грузообработка.
    int : n_cargo_types;
    int : n_obj_with_storage;
    array [1..n_obj_with_storage, 0..(n_intervals + 1), 1..n_cargo_types] of var int : storage_used_volume; % Первые n_moving_obj соответствуют наполненности соответствующих движущихся объектов.

    % Ограничения на вместимость.
        array [1..n_obj_with_storage] of int : max_storage_vol;
        % Максимальный объём.
        constraint forall (storage in 1..n_obj_with_storage, t in 0..(n_intervals + 1)) (
            sum (cargo in 1..n_cargo_types) (storage_used_volume[storage, t, cargo]) <= max_storage_vol[storage]
        );
        % Неотрицательность объёма.
        constraint forall (storage in 1..n_obj_with_storage, t in 0..(n_intervals + 1), cargo in 1..n_cargo_types) (
            0 <= storage_used_volume[storage, t, cargo]
        );

    % Ограничения на граничные значения.
        array [1..n_obj_with_storage, 1..n_cargo_types] of int : initial_storage_vol;
        array [1..n_obj_with_storage, 1..n_cargo_types] of int : final_storage_vol;

        constraint forall (storage in 1..n_obj_with_storage, cargo in 1..n_cargo_types) ( % Initial values.
            storage_used_volume[storage, 0, cargo] = initial_storage_vol[storage, cargo]
        );

        constraint forall (storage in 1..n_obj_with_storage, cargo in 1..n_cargo_types % Final values.
                            where final_storage_vol[storage, cargo] >= 0) (
                storage_used_volume[storage, n_intervals + 1, cargo] = final_storage_vol[storage, cargo]
        );

    % Изменение грузов в хранилищах.
        array [1..n_obj_with_storage, 0..(n_intervals + 1), 1..n_cargo_types] of int : cargo_flows;

        int : n_loading_op;

        array [1..n_operations] of int : loading_op_delta_of_main_obj;
        array [1..n_operations] of 1..n_obj_with_storage : operations_main_stor;
        array [1..n_operations] of 1..n_obj_with_storage : operations_secondary_stor;
        array [1..n_operations] of 1..n_cargo_types : operations_cargo_t;

        array [1..n_loading_op] of int : loading_op_delta;
        array [1..n_loading_op] of 1..n_operations : loading_op_n; % Номера среди общего списка операций.

        array [1..n_obj_with_storage, 1..n_cargo_types] of set of 1..n_loading_op : involved_operations;

        constraint forall (storage in 1..n_obj_with_storage, cargo in 1..n_cargo_types, t in 1..(n_intervals + 1)) (
            storage_used_volume[storage, t, cargo] = (
                storage_used_volume[storage, t - 1, cargo] +
                cargo_flows[storage, t, cargo] +
                sum (inv_op in involved_operations[storage, cargo]) (
                    loading_op_delta[inv_op] *
                    op_status[loading_op_n[inv_op], t]
                )
            )
        );

% Фиксированные операции.
    int : n_fixed_op;
    array [1..n_fixed_op] of 1..n_operations : fixed_op;
    array [1..n_fixed_op] of set of 1..n_moving_obj : fixed_op_resources;
    array [1..n_fixed_op] of 1..n_intervals : fixed_op_start;
    array [1..n_fixed_op] of 1..n_intervals : fixed_op_end; % Включительно.

    array [1..n_operations, 1..n_intervals] of bool : is_fixed;

    constraint forall (no in 1..n_fixed_op, op = fixed_op[no]) (
        forall (t in fixed_op_start[no]..fixed_op_end[no]) (
            (op_status[op, t]) /\
            forall (obj in fixed_op_resources[no]) (
                participation_as_resource[obj, t] = op
            )
        )
    );

% Оптимизация - сдвиг в начало.
    % Возможно ли начать операцию в данный интервал (если предположить, что операция длится 1 интервал).
    array [1..n_operations, 1..n_intervals] of var bool : is_op_possible;

    % Счётчик ресурсов, которые могут быть потенциально задействованы в операции.
    array [1..n_resources_counters , 1..n_intervals] of var int : possible_resources_counter;

    % Определение possible_resources_counter.
        constraint forall (counter in 1..n_resources_counters, t in 1..n_intervals) (
            possible_resources_counter[counter, t] = sum (obj in objects_of_type[counter_type[counter]]) (
                (participation_as_resource[obj, t] = 0) /\
                (current_moving_operation[obj, t] = 0)  /\
                (m_obj_loc[obj, t] = operations_resources_start_loc[counter])
            )
        );

    % Достаточно ли свободных ресурсов для операции.
    array [1..n_operations, 1..n_intervals] of var bool : is_enough_free_resources;

        constraint forall (op in 1..n_operations, t in 1..n_intervals) (
            is_enough_free_resources[op, t] = forall (counter in counters_of_operation[op]) (
                possible_resources_counter[counter, t] >= required_counter_values[counter]
            )
        );

    array [1..n_operations, 1..n_intervals] of var bool : debug_1;
        constraint forall (op in 1..n_operations, t in 1..n_intervals) (
            debug_1[op, t] =
                (m_obj_loc[main_obj_of_operation[op], t] = main_obj_start_loc[op]) % Главный объект на месте.
        );

    % Определение is_op_possible.
        constraint forall (op in 1..n_operations, t in 1..n_intervals) (
            is_op_possible[op, t] = (
                (bad_weather[op, t] = false) /\                  % Погода не мешает.
                (m_obj_loc[main_obj_of_operation[op], t] = main_obj_start_loc[op])
                                                              /\ % Главный объект на месте.
                (current_moving_operation[main_obj_of_operation[op], t] = 0)
                                                              /\ % Главный объект не участвует в операции перемещеня.
                (is_enough_free_resources[op, t] = true)      /\ % Достаточно свободных ресурсов на нужном месте.
                (forall (conf_op in conflicting_operations[op]) (op_status[op, t] = false))
                                                              /\ % Не выполняется ни одной конфликтующей операции.
                (is_moving_operation[op] -> not is_involved_in_cargo_op[main_obj_of_operation[op], t])
                                                              /\ % Если это операция перемещения, то главный объект
                                                                 % не участвует в операциях погрузки.
                ((is_mooring_op[op] /\ (operations_destination[op] mod 2 = 0)) -> (
                    obj_in_loc_counter[operations_destination[op], t] = 0)
                )                                             /\ % Если это операция пришвартовки, то в этот интервал
                                                                 % причал должен быть свободным.
                ((not is_moving_operation[op]) -> (
                    let {1..n_obj_with_storage : m_stor = operations_main_stor[op];
                         1..n_obj_with_storage : s_stor = operations_secondary_stor[op];
                         1..n_cargo_types      : cargo = operations_cargo_t[op];
                         int                   : delta = loading_op_delta_of_main_obj[op];
                        } in
                    (storage_used_volume[m_stor, t, cargo] + delta >= 0) /\
                    ((sum (c in 1..n_cargo_types) (storage_used_volume[m_stor, t, cargo])) + delta <= max_storage_vol[m_stor]) /\
                    (storage_used_volume[s_stor, t, cargo] - delta >= 0) /\
                    ((sum (c in 1..n_cargo_types) (storage_used_volume[s_stor, t, cargo])) - delta <= max_storage_vol[s_stor])
                ))                                            /\ % Если это операция грузообработки, то она не выведет
                                                                 % объём берегового хранилища и хранилища судна за
                                                                 % границы дозволенного.
                (((not is_moving_operation[op]) /\ (main_obj_start_loc[op] mod 2 = 1)) ->
                    (obj_in_loc_counter[twin_location[main_obj_start_loc[op]], t] = 0)
                )                                                % Если это операция грузообработки без пришвартовки,
                                                                 % то причал должен быть свободен в этот интервал.
            )
        );

    % Сам критерий оптимизации - если если операцию можно было начать на 1 интервал раньше, то её нужно начать раньше.
        constraint forall (op in 1..n_operations, t in 2..n_intervals) (
            (op_start[op, t] /\ (not is_fixed[op, t])) -> not is_op_possible[op, t - 1]
        );

% Критерий оптимизации
    array [1..(n_intervals + 1)] of var bool : is_not_terminated;
    % В конце всё остановится.
    constraint (is_not_terminated[n_intervals + 1] == false);

    % Действия ещё не остановились, если в текущий интервал что-нибудь происходит или они не остановятся в следующий интервал.
    constraint forall (t in 1..n_intervals) (
        is_not_terminated[t] == (
            (exists (op in 1..n_operations) (op_status[op, t]))
                \/
            is_not_terminated[t + 1]
        )
    );

    solve minimize sum(is_not_terminated);

output [show(sum(is_not_terminated)), "\n",
        "op_status = ", show(op_status), "\n\n",
        "m_obj_loc = ", show(m_obj_loc), "\n\n",
        "op_start = ", show(op_start), "\n\n",
        "is_not_terminated = ", show(is_not_terminated), "\n\n",
        "storage_used_volume = ", show(storage_used_volume), "\n\n",
        "is_m_obj_in_movement_before_start = ", show(is_m_obj_in_movement_before_start), "\n\n",
        "obj_in_loc_counter = ", show(obj_in_loc_counter), "\n\n",
        "m_obj_loc = ", show(m_obj_loc), "\n\n",
        "current_moving_operation = ", show(current_moving_operation), "\n\n",
        "resources_counter {", show(n_intervals), "} = ", show(resources_counter), "\n\n",
        "operation_of_counter {", show(n_resources_counters), "} = ", show(operation_of_counter), "\n\n",
        "participation_as_resource = ", show(participation_as_resource), "\n\n",
/*
        "is_op_possible {", show(n_intervals), "} = ", show(is_op_possible), "\n\n",
        "debug_1 {", show(n_intervals), "} = ", show(debug_1), "\n\n",
        "is_enough_free_resources {", show(n_intervals), "} = ", show(is_enough_free_resources), "\n\n",
        "operation_of_counter {", show(n_resources_counters), "} = ", show(operation_of_counter), "\n\n",
        "possible_resources_counter {", show(n_intervals), "} = ", show(possible_resources_counter), "\n\n",
*/
        ""];