How can I get the inversion Laplace to function val?

I wrote the code using function Talbot but I expect the result at t tends to infty it should give 1 because I divide it to the function of steady case at sigma=0

sh1()

function sh1()
clc; close all;
    t_values = logspace(0, 3, 100);
    c_vals = [1, 4, 6, 10]; % 4 specific curves to compare
    params = struct('s1',2, 'rho1',0,'s2',0, 'alpha',1, 'j',0.1,'mu1',1,'mu2',0.001);
    figure; hold on;
    colors = ['r', 'g', 'b', 'm']; % 4 colors for the three curves


    % Steady-state velocity for this value of c

    for k = 1:length(c_vals)
        params.c = c_vals(k);
        u_s1 = zeros(size(t_values));

        for i = 1:length(t_values)
            % Compute both inversions at the current c
            u_s1(i) = talbot_inversion(@(sigma) U_func_s1(sigma, params), t_values(i));
        end

        % Calculate ratio
        ratio = u_s1  ;

        % Plot
        plot(t_values, ratio, 'Color', colors(k), 'LineWidth', 2, ...
            'DisplayName', sprintf('c=%.2f', c_vals(k)));
    end

    set(gca, 'XScale', 'log');
    xlabel('Time (t)'); ylabel('Ratio (U_{uns}/U_{std})');
    legend('Location', 'best'); grid on;
%    title('Effect of Micropolar Coupling on Dispersion Ratio');
end

% --- Rename your existing logic to avoid conflicts ---
function val = U_func_s1(sigma, p)
    % Copy your logic from the original calc_s1.m U_function here
    % Ensure it returns 'val'
    % Unpack1
    s1 = p.s1; alpha=p.alpha; 
    s2 = p.s2; c = p.c; j = p.j; rho1 = p.rho1; 
    mu2=p.mu2; mu1=p.mu1;


    % Define S (sum) and P (product)
    xi=sqrt(alpha^2+sigma);
    l = sqrt(c*s1*(2+c)/(1+c));

    % Calculate roots
    S0 = l^2 + (sigma * (1 + j * s1 * (1 + c))) / (1 + c);
    P0 = (sigma * s1 * (4 * c + j * sigma)) / (1 + c);  
    lambda1 = sqrt((S0 - sqrt(S0^2 - 4*P0)) / 2);
    lambda2 = sqrt((S0 + sqrt(S0^2 - 4*P0)) / 2);

   x1 = -(-(72 * lambda1 ^ 2 * lambda2 * mu1) - (72 * lambda1 * lambda2 ^ 2 * mu1) - (36 * lambda1 * mu1 * xi ^ 2) + (24 * lambda1 * mu2 * xi ^ 2) - (36 * lambda2 * mu1 * xi ^ 2) + (24 * lambda2 * mu2 * xi ^ 2) + (72 * c * lambda1 * lambda2 * xi) + (12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) - (72 * c * lambda2 * mu1) + (72 * c * lambda2 * mu2) + (72 * c * lambda1 * mu2) - (72 * c * lambda2 ^ 2 * mu1) + (72 * c * lambda2 ^ 2 * mu2) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (36 * c ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (72 * lambda2 * mu1) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (24 * lambda1 * lambda2 * mu1 * xi ^ 3) - (144 * lambda1 * lambda2 * mu1) - (72 * lambda1 ^ 2 * mu1) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (12 * c * lambda2 * mu1 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * lambda1 * mu1 * xi ^ 3) - (12 * lambda2 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2) + (72 * lambda2 ^ 2 * mu2) + (72 * lambda1 * mu2) + (72 * lambda2 * mu2) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) - (24 * c * lambda1 * lambda2 * mu1 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1) + (72 * c * lambda1 ^ 2 * mu2) + (144 * c * lambda1 * lambda2 * mu2) + (36 * c ^ 2 * lambda1 ^ 2 * xi) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2) + (12 * c ^ 2 * lambda1 * xi ^ 2) + (12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda2 * xi ^ 2) + (36 * c * lambda1 * xi) + (36 * c * lambda2 * xi) + (36 * c ^ 2 * lambda2) + (36 * c ^ 2 * lambda1) + (24 * c * lambda1 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 3) + (36 * c ^ 2 * lambda1 ^ 2) + (36 * c ^ 2 * lambda2 ^ 2) + (72 * c ^ 2 * lambda1 * lambda2) + (36 * c * lambda2 ^ 2) + (36 * c * lambda1) + (36 * c * lambda2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (6 * c * lambda1 * s2 * xi ^ 3) + (6 * c * lambda2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 2) + (72 * c ^ 2 * lambda1 * lambda2 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2) - (36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) - (72 * lambda2 ^ 2 * mu1 * xi) + (72 * lambda2 ^ 2 * mu2 * xi) - (12 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * c * lambda2 * mu1 * xi) + (72 * c * lambda2 * mu2 * xi) - (144 * c * lambda1 * lambda2 * mu1) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2) - (36 * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * lambda2 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) - (144 * lambda1 * lambda2 * mu1 * xi) + (144 * lambda1 * lambda2 * mu2 * xi) + (72 * lambda1 * lambda2 ^ 2 * mu2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * lambda1 * lambda2 ^ 2 * mu1 * xi) - (72 * lambda1 ^ 2 * lambda2 * mu1 * xi) + (36 * c * lambda1 ^ 2 * lambda2) + (36 * c * lambda1 * lambda2 ^ 2) + (72 * c * lambda1 * lambda2) - (36 * c * lambda2 * mu1 * xi ^ 2) + (24 * c * lambda2 * mu2 * xi ^ 2) + (24 * c * lambda1 * mu2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2) - (72 * c * lambda1 * lambda2 ^ 2 * mu1) - (72 * c * lambda1 ^ 2 * lambda2 * mu1) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) - (72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi) - (72 * lambda1 * mu1 * xi) + (72 * lambda1 * mu2 * xi) - (72 * lambda2 * mu1 * xi) + (72 * lambda2 * mu2 * xi) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * lambda1 ^ 2 * xi ^ 3 * mu1) - (36 * lambda1 ^ 2 * xi ^ 2 * mu1) - (72 * lambda1 ^ 2 * mu1 * xi) + (24 * lambda1 ^ 2 * mu2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2) - (36 * c * lambda1 * mu1 * xi ^ 2) + (48 * c * lambda1 * lambda2 * mu2 * xi ^ 2) - (144 * c * lambda1 * lambda2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (36 * c ^ 2 * lambda1 * xi) + (36 * c ^ 2 * lambda2 * xi) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 2) - (12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * lambda1 * mu1) - (72 * lambda2 ^ 2 * mu1) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (36 * c * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * c * lambda2 ^ 2 * mu2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * lambda2 * xi) + (36 * c * lambda1 * lambda2 ^ 2 * xi) - (72 * c * lambda2 ^ 2 * mu1 * xi) + (72 * c * lambda2 ^ 2 * mu2 * xi) + (6 * c * lambda1 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 * mu2 * s2 * xi ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) - (12 * c * lambda2 ^ 2 * mu1 * xi ^ 3) + (12 * c ^ 2 * lambda2 * xi ^ 2) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 3) - (6 * c * lambda1 * sigma * xi) - (72 * c * lambda1 * mu1) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2) - (72 * c * lambda1 * mu1 * xi) + (72 * c * lambda1 * mu2 * xi) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) + (72 * c * lambda1 ^ 2 * mu2 * xi) + (36 * c * lambda1 ^ 2) + (24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2) + (24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) - (72 * lambda1 * lambda2 * mu1 * xi ^ 2) + (48 * lambda1 * lambda2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) - (12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (24 * c * lambda1 * lambda2 * xi ^ 2) + (6 * c * lambda1 * s2 * xi ^ 2) + (6 * c * lambda2 * s2 * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi) - (12 * c * lambda1 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (12 * c * lambda2 ^ 2 * xi ^ 2) + (36 * c * lambda2 ^ 2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi) - (72 * c * lambda1 * lambda2 * mu1 * xi ^ 2) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * mu1 * xi ^ 3) + (12 * c * lambda1 * xi ^ 2) - (36 * c * lambda1 ^ 2 * mu1 * xi ^ 2) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda1 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 * mu2 * s2 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1 * xi) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi) + (144 * c * lambda1 * lambda2 * mu2 * xi) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2) + (72 * lambda1 * lambda2 ^ 2 * mu2) + (144 * lambda1 * lambda2 * mu2) + (12 * c * lambda1 ^ 2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3 + 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 + 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3 - 12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 + 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2 - 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda2 * s2 * xi ^ 3 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 12 * c * lambda1 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * s2 * xi ^ 3 + 36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 - 24 * c * lambda1 * lambda2 * mu1 * xi ^ 3 - 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 + 12 * c * lambda1 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 12 * c * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2 + 36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi - 24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda2 * s2 * xi ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi - 72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi + 72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 - 72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi - 12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * c * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * c * lambda1 * lambda2 * s2 * xi ^ 2 - 12 * c * lambda1 * mu1 * xi ^ 3 - 6 * c * lambda1 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * s2 * sigma * xi ^ 2 + 6 * c * lambda1 * s2 * xi ^ 3 + 36 * c * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 - 12 * c * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 + 6 * c * lambda2 * s2 * xi ^ 3 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi + 36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * xi ^ 3 * mu1 + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 + 36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 - 24 * lambda1 * lambda2 * mu1 * xi ^ 3 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 - 12 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 36 * c ^ 2 * lambda1 ^ 2 * lambda2 + 36 * c ^ 2 * lambda1 ^ 2 * xi - 36 * c ^ 2 * lambda1 * lambda2 ^ 2 + 72 * c ^ 2 * lambda1 * lambda2 * xi - 12 * c ^ 2 * lambda1 * xi ^ 2 + 36 * c ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda2 * xi ^ 2 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 + 72 * c * lambda1 ^ 2 * lambda2 * mu1 - 72 * c * lambda1 ^ 2 * lambda2 * mu2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 36 * c * lambda1 ^ 2 * lambda2 * xi - 72 * c * lambda1 ^ 2 * mu1 * xi + 72 * c * lambda1 ^ 2 * mu2 * xi + 6 * c * lambda1 ^ 2 * sigma * xi - 12 * c * lambda1 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 ^ 2 * mu1 - 72 * c * lambda1 * lambda2 ^ 2 * mu2 - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 36 * c * lambda1 * lambda2 ^ 2 * xi - 144 * c * lambda1 * lambda2 * mu1 * xi + 144 * c * lambda1 * lambda2 * mu2 * xi - 24 * c * lambda1 * lambda2 * xi ^ 2 + 36 * c * lambda1 * mu1 * xi ^ 2 - 24 * c * lambda1 * mu2 * xi ^ 2 - 6 * c * lambda1 * s2 * xi ^ 2 + 2 * c * lambda1 * sigma * xi ^ 2 - 72 * c * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda2 ^ 2 * sigma * xi - 12 * c * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda2 * s2 * xi ^ 2 + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 - 72 * lambda1 ^ 2 * lambda2 * mu1 * xi + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma + 72 * lambda1 ^ 2 * lambda2 * mu2 * xi + 36 * lambda1 ^ 2 * xi ^ 2 * mu1 - 12 * lambda1 ^ 2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * mu2 * xi ^ 2 - 72 * lambda1 * lambda2 ^ 2 * mu1 * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda1 * lambda2 ^ 2 * mu2 * xi + 24 * lambda1 * lambda2 * mu1 * sigma * xi + 72 * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 * mu1 * sigma * xi ^ 2 - 12 * lambda1 * mu1 * xi ^ 3 + 12 * lambda1 * mu2 * sigma * xi ^ 2 + 36 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda2 * mu1 * sigma * xi ^ 2 - 12 * lambda2 * mu1 * xi ^ 3 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 36 * c ^ 2 * lambda1 ^ 2 - 72 * c ^ 2 * lambda1 * lambda2 + 36 * c ^ 2 * lambda1 * xi - 36 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda2 * xi - 36 * c * lambda1 ^ 2 * lambda2 + 72 * c * lambda1 ^ 2 * mu1 - 72 * c * lambda1 ^ 2 * mu2 - 6 * c * lambda1 ^ 2 * sigma + 36 * c * lambda1 ^ 2 * xi - 36 * c * lambda1 * lambda2 ^ 2 + 144 * c * lambda1 * lambda2 * mu1 - 144 * c * lambda1 * lambda2 * mu2 + 72 * c * lambda1 * lambda2 * xi - 72 * c * lambda1 * mu1 * xi + 72 * c * lambda1 * mu2 * xi - 6 * c * lambda1 * sigma * xi - 12 * c * lambda1 * xi ^ 2 + 72 * c * lambda2 ^ 2 * mu1 - 72 * c * lambda2 ^ 2 * mu2 - 6 * c * lambda2 ^ 2 * sigma + 36 * c * lambda2 ^ 2 * xi - 72 * c * lambda2 * mu1 * xi + 72 * c * lambda2 * mu2 * xi - 6 * c * lambda2 * sigma * xi - 12 * c * lambda2 * xi ^ 2 + 72 * lambda1 ^ 2 * lambda2 * mu1 - 72 * lambda1 ^ 2 * lambda2 * mu2 - 72 * lambda1 ^ 2 * mu1 * xi + 12 * lambda1 ^ 2 * mu2 * sigma + 72 * lambda1 ^ 2 * mu2 * xi + 72 * lambda1 * lambda2 ^ 2 * mu1 - 72 * lambda1 * lambda2 ^ 2 * mu2 - 24 * lambda1 * lambda2 * mu1 * sigma - 144 * lambda1 * lambda2 * mu1 * xi + 48 * lambda1 * lambda2 * mu2 * sigma + 144 * lambda1 * lambda2 * mu2 * xi + 24 * lambda1 * mu1 * sigma * xi + 36 * lambda1 * mu1 * xi ^ 2 - 36 * lambda1 * mu2 * sigma * xi - 24 * lambda1 * mu2 * xi ^ 2 - 72 * lambda2 ^ 2 * mu1 * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda2 ^ 2 * mu2 * xi + 24 * lambda2 * mu1 * sigma * xi + 36 * lambda2 * mu1 * xi ^ 2 - 36 * lambda2 * mu2 * sigma * xi - 24 * lambda2 * mu2 * xi ^ 2 - 36 * c ^ 2 * lambda1 - 36 * c ^ 2 * lambda2 - 36 * c * lambda1 ^ 2 - 72 * c * lambda1 * lambda2 + 72 * c * lambda1 * mu1 - 72 * c * lambda1 * mu2 + 6 * c * lambda1 * sigma + 36 * c * lambda1 * xi - 36 * c * lambda2 ^ 2 + 72 * c * lambda2 * mu1 - 72 * c * lambda2 * mu2 + 6 * c * lambda2 * sigma + 36 * c * lambda2 * xi + 72 * lambda1 ^ 2 * mu1 - 72 * lambda1 ^ 2 * mu2 + 144 * lambda1 * lambda2 * mu1 - 144 * lambda1 * lambda2 * mu2 - 24 * lambda1 * mu1 * sigma - 72 * lambda1 * mu1 * xi + 36 * lambda1 * mu2 * sigma + 72 * lambda1 * mu2 * xi + 72 * lambda2 ^ 2 * mu1 - 72 * lambda2 ^ 2 * mu2 - 24 * lambda2 * mu1 * sigma - 72 * lambda2 * mu1 * xi + 36 * lambda2 * mu2 * sigma + 72 * lambda2 * mu2 * xi - 36 * c * lambda1 - 36 * c * lambda2 + 72 * lambda1 * mu1 - 72 * lambda1 * mu2 + 72 * lambda2 * mu1 - 72 * lambda2 * mu2) * exp((2 * xi))) / (-(12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi + 2 * c * lambda1 * s2 * sigma * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 6 * c * lambda1 ^ 2 * sigma * xi - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 2 * c * lambda1 * sigma * xi ^ 2 + 6 * c * lambda2 ^ 2 * sigma * xi + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma - 12 * lambda1 ^ 2 * mu2 * sigma * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda1 * lambda2 * mu1 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 12 * lambda1 * mu1 * sigma * xi ^ 2 + 12 * lambda1 * mu2 * sigma * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda2 * mu1 * sigma * xi ^ 2 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 6 * c * lambda1 ^ 2 * sigma - 6 * c * lambda1 * sigma * xi - 6 * c * lambda2 ^ 2 * sigma - 6 * c * lambda2 * sigma * xi + 12 * lambda1 ^ 2 * mu2 * sigma - 24 * lambda1 * lambda2 * mu1 * sigma + 48 * lambda1 * lambda2 * mu2 * sigma + 24 * lambda1 * mu1 * sigma * xi - 36 * lambda1 * mu2 * sigma * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda2 * mu1 * sigma * xi - 36 * lambda2 * mu2 * sigma * xi + 6 * c * lambda1 * sigma + 6 * c * lambda2 * sigma - 24 * lambda1 * mu1 * sigma + 36 * lambda1 * mu2 * sigma - 24 * lambda2 * mu1 * sigma + 36 * lambda2 * mu2 * sigma) * exp((2 * xi)) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) - (6 * c * lambda1 * sigma * xi) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi)) / 0.2e1;
   x0=-(1/2)*(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1-6*alpha*c*l^3*mu1-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2+3*alpha^2*c^2*l*s2-3*alpha^2*l^3*mu1*mu2-3*alpha^2*l^2*mu1*mu2-6*l^3*mu1*mu2-6*l^2*mu1*mu2+9*c^2-alpha^3*l^3*mu1*mu2-alpha^3*l^2*mu1*mu2-6*alpha*l^3*mu1*mu2-6*alpha*l^2*mu1*mu2+3*alpha^2*c^2+9*c^2*l-18*c*mu1+9*alpha*c^2+3*c^2*l^2+alpha^2*c^2*l^2-6*c*l^3*mu1-12*c*l^2*mu1+6*c*l^2*mu2+3*alpha*c^2*l^2+6*alpha^2*c*l*mu2*s2-9*alpha^2*c*l*mu1+6*alpha^2*c*l*mu2+6*alpha^2*c*mu2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-18*alpha*c*l*mu1+18*alpha*c*l*mu2-18*alpha*c*mu1+18*alpha*c*mu2+18*mu2*c+3*alpha^2*c^2*l+3*alpha^2*c^2*s2-9*alpha^2*c*mu1+6*alpha^2*c*mu2-18*c*l*mu1+18*c*l*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*mu1+9*alpha*c^2*l+(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+2*alpha^3*c*l^2*mu2*s2-alpha^3*l^3*mu1*mu2+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1+6*alpha^3*c*l*mu2*s2-alpha^3*l^2*mu1*mu2-alpha^2*c^2*l^2*s2+3*alpha^2*c*l^3*mu1-2*alpha^2*c*l^2*mu2*s2+3*alpha^2*l^3*mu1*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-alpha^2*c^2*l^2-3*alpha^2*c^2*l*s2+6*alpha^2*c*l^2*mu1-2*alpha^2*c*l^2*mu2-6*alpha^2*c*l*mu2*s2+3*alpha^2*l^2*mu1*mu2-6*alpha*c*l^3*mu1-6*alpha*l^3*mu1*mu2-3*alpha^3*c*mu1-3*alpha^2*c^2*l-3*alpha^2*c^2*s2+9*alpha^2*c*l*mu1-6*alpha^2*c*l*mu2-6*alpha^2*c*mu2*s2+3*alpha*c^2*l^2-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2-6*alpha*l^2*mu1*mu2+6*c*l^3*mu1+6*l^3*mu1*mu2-3*alpha^2*c^2+9*alpha^2*c*mu1-6*alpha^2*c*mu2+9*alpha*c^2*l-18*alpha*c*l*mu1+18*alpha*c*l*mu2-3*c^2*l^2+12*c*l^2*mu1-6*c*l^2*mu2+6*l^2*mu1*mu2+9*alpha*c^2-18*alpha*c*mu1+18*alpha*c*mu2-9*c^2*l+18*c*l*mu1-18*c*l*mu2-9*c^2+18*c*mu1-18*c*mu2)*exp(2*alpha)+2*alpha^2*c*l^2*mu2*s2+2*alpha^3*c*l^2*mu2*s2+6*alpha^3*c*l*mu2*s2+alpha^2*c^2*l^2*s2-3*alpha^2*c*l^3*mu1-6*alpha^2*c*l^2*mu1+2*alpha^2*c*l^2*mu2)/(l^2*((alpha^3*c^2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+2*alpha^3*l*mu1*mu2+alpha^3*c*mu1+2*alpha^3*mu1*mu2+3*alpha^2*c^2*l-alpha^2*c^2*s2-6*alpha^2*c*l*mu1+9*alpha^2*c*l*mu2-2*alpha^2*c*mu2*s2-6*alpha^2*l*mu1*mu2+6*alpha^2*l*mu2^2+2*alpha^2*c^2-3*alpha^2*c*mu1+7*alpha^2*c*mu2-6*alpha^2*mu1*mu2+6*alpha^2*mu2^2-9*alpha*c^2*l+12*alpha*c*l*mu1-27*alpha*c*l*mu2+12*alpha*l*mu1*mu2-18*alpha*l*mu2^2-6*alpha*c^2+6*alpha*c*mu1-21*alpha*c*mu2+12*alpha*mu1*mu2-18*alpha*mu2^2+9*c^2*l-12*c*l*mu1+27*c*l*mu2-12*l*mu1*mu2+18*l*mu2^2+6*c^2-6*c*mu1+21*c*mu2-12*mu1*mu2+18*mu2^2)*exp(2*alpha)-6*alpha^2*l*mu2^2+6*alpha^2*mu1*mu2+12*l*mu1*mu2-6*alpha^2*mu2^2-18*l*mu2^2+12*mu1*mu2-6*c^2+2*alpha^3*l*mu1*mu2+12*alpha*l*mu1*mu2-2*alpha^2*c^2-9*c^2*l+6*c*mu1-6*alpha*c^2-18*alpha*mu2^2+2*alpha^3*mu1*mu2-18*alpha*l*mu2^2+12*alpha*mu1*mu2+6*alpha^2*l*mu1*mu2+6*alpha^2*c*l*mu1-9*alpha^2*c*l*mu2+2*alpha^2*c*mu2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+12*alpha*c*l*mu1-27*alpha*c*l*mu2+6*alpha*c*mu1-21*alpha*c*mu2-21*mu2*c-18*mu2^2-3*alpha^2*c^2*l+alpha^2*c^2*s2+3*alpha^2*c*mu1-7*alpha^2*c*mu2+12*c*l*mu1-27*c*l*mu2+alpha^3*c^2*s2+alpha^3*c*mu1-9*alpha*c^2*l));
  
   val =(3/(4*pi*sigma^2*(rho1-1 -3*x1)))/(1/(2*(2+c)*pi*x0));
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function ilt = talbot_inversion(F, t, M)
    % TALBOT_INVERSION
    % Numerical inverse Laplace transform using the fixed Talbot method
    %
    % ilt = talbot_inversion(F, t, M)
    %
    % Inputs:
    %   F : function handle representing F(s)
    %   t : scalar or vector of positive time values
    %   M : number of Talbot terms, default = 64
    %
    % Output:
    %   ilt : numerical inverse Laplace transform at t

    % Default number of terms
    if nargin < 3
        M = 64;
    end

    % Preserve the original shape of t
    original_size = size(t);

    % Convert t to a column vector
    t = t(:);

    % Check that all time values are positive
    if any(t <= 0)
        error('All time values must be positive.');
    end

    % Preallocate result
    ilt = zeros(length(t), 1);

    % Talbot contour angles
    k = 1:(M-1);
    theta = (pi/M) * k;
    cot_theta = cot(theta);

    % Talbot contour parameters
    delta = zeros(1, M);

    % Correct first contour point
    delta(1) = 2*M/5;

    delta(2:end) = ...
        (2*M/5) * theta .* (cot_theta + 1i);

    % Talbot weights
    gamma = zeros(1, M);

    gamma(1) = 0.5 * exp(delta(1));

    gamma(2:end) = ...
        (1 ...
        + 1i*theta.*(1 + cot_theta.^2) ...
        - 1i*cot_theta) ...
        .* exp(delta(2:end));

    % Evaluate the inverse transform
    for i = 1:length(t)

        s_vals = delta / t(i);

        f_vals = arrayfun(F, s_vals);

        ilt(i) = ...
            (0.4/t(i)) * sum(real(gamma .* f_vals));

    end

    % Restore original shape
    ilt = reshape(ilt, original_size);

end

[dpb]

What's different here than in prior question <Answers 2184281 Plot after taking inversion laplace and then divide it steady state?>? It was shown there that the functional that was supposed to calculate a steady-state value was not correct in that it returned a time-dependent value of the wrong sign and magnitude and that the inversion functional was unstable as the time was increased although there was a range that approached a SS value before it blew up entirely.

Does your evaluation function actually compute a stable steady state value now, if you've been able to solve that issue, the prior solution to evaluate the function for a very large time should work. Otherwise, you would have have been able to characterize the system behavior from first principles (how were the functional and its coefficients determined to start with?) to be able to compute an analytical SS value.

Lacking one of those, it would seem would be plowing over the same ground again.

Also not the sidebar conversation about the inversion technique itself raises some serious questions about it as well...

[Torsten]

Obviously, the Inverse Laplace transform of

3/(4*pi*sigma^2*(rho1-1 -3*x1))

does not tend to

(1/(2*(2+c)*pi*x0))

as t -> Inf as you can see from the below code (which is the same code as yours ; only the factor that you think of is steady-state has been extracted and computed separately).

I don't know why you think the Inverse Laplace transform of

3/(4*pi*sigma^2*(rho1-1 -3*x1))

should tend to

(1/(2*(2+c)*pi*x0))

as t -> Inf because I don't know the background of your problem.

Maybe you could get a more useful answer if you gave an explanation.

Mathematica and Python have internal functions for the computation of Numerical Inverse Laplace Transform. It might be worth testing what you get with these reliable codes instead of your "simple" Talbot code.

sh1()

function sh1()
clc; close all;
    t_values = logspace(0, 3, 100);
    c_vals = [1, 4, 6, 10]; % 4 specific curves to compare
    params = struct('s1',2, 'rho1',0,'s2',0, 'alpha',1, 'j',0.1,'mu1',1,'mu2',0.001);
    figure; hold on;
    colors = ['r', 'g', 'b', 'm']; % 4 colors for the three curves


    % Steady-state velocity for this value of c

    for k = 1:length(c_vals)
        params.c = c_vals(k);
        u_s1 = zeros(size(t_values));

        for i = 1:length(t_values)
            % Compute both inversions at the current c
            u_s1(i) = talbot_inversion(@(sigma) U_func_s1(sigma, params), t_values(i));
        end

        % Calculate ratio
        ratio = u_s1/normalize(params);

        % Plot
        plot(t_values, ratio, 'Color', colors(k), 'LineWidth', 2, ...
            'DisplayName', sprintf('c=%.2f', c_vals(k)));
    end

    set(gca, 'XScale', 'log');
    xlabel('Time (t)'); ylabel('Ratio (U_{uns}/U_{std})');
    legend('Location', 'best'); grid on;
%    title('Effect of Micropolar Coupling on Dispersion Ratio');
end

% --- Rename your existing logic to avoid conflicts ---
function val = U_func_s1(sigma, p)
    % Copy your logic from the original calc_s1.m U_function here
    % Ensure it returns 'val'
    % Unpack1
    s1 = p.s1; alpha=p.alpha; 
    s2 = p.s2; c = p.c; j = p.j; rho1 = p.rho1; 
    mu2=p.mu2; mu1=p.mu1;


    % Define S (sum) and P (product)
    xi=sqrt(alpha^2+sigma);
    l = sqrt(c*s1*(2+c)/(1+c));

    % Calculate roots
    S0 = l^2 + (sigma * (1 + j * s1 * (1 + c))) / (1 + c);
    P0 = (sigma * s1 * (4 * c + j * sigma)) / (1 + c);  
    lambda1 = sqrt((S0 - sqrt(S0^2 - 4*P0)) / 2);
    lambda2 = sqrt((S0 + sqrt(S0^2 - 4*P0)) / 2);

   x1 = -(-(72 * lambda1 ^ 2 * lambda2 * mu1) - (72 * lambda1 * lambda2 ^ 2 * mu1) - (36 * lambda1 * mu1 * xi ^ 2) + (24 * lambda1 * mu2 * xi ^ 2) - (36 * lambda2 * mu1 * xi ^ 2) + (24 * lambda2 * mu2 * xi ^ 2) + (72 * c * lambda1 * lambda2 * xi) + (12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) - (72 * c * lambda2 * mu1) + (72 * c * lambda2 * mu2) + (72 * c * lambda1 * mu2) - (72 * c * lambda2 ^ 2 * mu1) + (72 * c * lambda2 ^ 2 * mu2) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (36 * c ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (72 * lambda2 * mu1) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (24 * lambda1 * lambda2 * mu1 * xi ^ 3) - (144 * lambda1 * lambda2 * mu1) - (72 * lambda1 ^ 2 * mu1) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (12 * c * lambda2 * mu1 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * lambda1 * mu1 * xi ^ 3) - (12 * lambda2 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2) + (72 * lambda2 ^ 2 * mu2) + (72 * lambda1 * mu2) + (72 * lambda2 * mu2) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) - (24 * c * lambda1 * lambda2 * mu1 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1) + (72 * c * lambda1 ^ 2 * mu2) + (144 * c * lambda1 * lambda2 * mu2) + (36 * c ^ 2 * lambda1 ^ 2 * xi) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2) + (12 * c ^ 2 * lambda1 * xi ^ 2) + (12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda2 * xi ^ 2) + (36 * c * lambda1 * xi) + (36 * c * lambda2 * xi) + (36 * c ^ 2 * lambda2) + (36 * c ^ 2 * lambda1) + (24 * c * lambda1 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 3) + (36 * c ^ 2 * lambda1 ^ 2) + (36 * c ^ 2 * lambda2 ^ 2) + (72 * c ^ 2 * lambda1 * lambda2) + (36 * c * lambda2 ^ 2) + (36 * c * lambda1) + (36 * c * lambda2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (6 * c * lambda1 * s2 * xi ^ 3) + (6 * c * lambda2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 2) + (72 * c ^ 2 * lambda1 * lambda2 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2) - (36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) - (72 * lambda2 ^ 2 * mu1 * xi) + (72 * lambda2 ^ 2 * mu2 * xi) - (12 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * c * lambda2 * mu1 * xi) + (72 * c * lambda2 * mu2 * xi) - (144 * c * lambda1 * lambda2 * mu1) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2) - (36 * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * lambda2 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) - (144 * lambda1 * lambda2 * mu1 * xi) + (144 * lambda1 * lambda2 * mu2 * xi) + (72 * lambda1 * lambda2 ^ 2 * mu2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * lambda1 * lambda2 ^ 2 * mu1 * xi) - (72 * lambda1 ^ 2 * lambda2 * mu1 * xi) + (36 * c * lambda1 ^ 2 * lambda2) + (36 * c * lambda1 * lambda2 ^ 2) + (72 * c * lambda1 * lambda2) - (36 * c * lambda2 * mu1 * xi ^ 2) + (24 * c * lambda2 * mu2 * xi ^ 2) + (24 * c * lambda1 * mu2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2) - (72 * c * lambda1 * lambda2 ^ 2 * mu1) - (72 * c * lambda1 ^ 2 * lambda2 * mu1) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) - (72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi) - (72 * lambda1 * mu1 * xi) + (72 * lambda1 * mu2 * xi) - (72 * lambda2 * mu1 * xi) + (72 * lambda2 * mu2 * xi) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * lambda1 ^ 2 * xi ^ 3 * mu1) - (36 * lambda1 ^ 2 * xi ^ 2 * mu1) - (72 * lambda1 ^ 2 * mu1 * xi) + (24 * lambda1 ^ 2 * mu2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2) - (36 * c * lambda1 * mu1 * xi ^ 2) + (48 * c * lambda1 * lambda2 * mu2 * xi ^ 2) - (144 * c * lambda1 * lambda2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (36 * c ^ 2 * lambda1 * xi) + (36 * c ^ 2 * lambda2 * xi) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 2) - (12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * lambda1 * mu1) - (72 * lambda2 ^ 2 * mu1) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (36 * c * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * c * lambda2 ^ 2 * mu2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * lambda2 * xi) + (36 * c * lambda1 * lambda2 ^ 2 * xi) - (72 * c * lambda2 ^ 2 * mu1 * xi) + (72 * c * lambda2 ^ 2 * mu2 * xi) + (6 * c * lambda1 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 * mu2 * s2 * xi ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) - (12 * c * lambda2 ^ 2 * mu1 * xi ^ 3) + (12 * c ^ 2 * lambda2 * xi ^ 2) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 3) - (6 * c * lambda1 * sigma * xi) - (72 * c * lambda1 * mu1) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2) - (72 * c * lambda1 * mu1 * xi) + (72 * c * lambda1 * mu2 * xi) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) + (72 * c * lambda1 ^ 2 * mu2 * xi) + (36 * c * lambda1 ^ 2) + (24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2) + (24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) - (72 * lambda1 * lambda2 * mu1 * xi ^ 2) + (48 * lambda1 * lambda2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) - (12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (24 * c * lambda1 * lambda2 * xi ^ 2) + (6 * c * lambda1 * s2 * xi ^ 2) + (6 * c * lambda2 * s2 * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi) - (12 * c * lambda1 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (12 * c * lambda2 ^ 2 * xi ^ 2) + (36 * c * lambda2 ^ 2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi) - (72 * c * lambda1 * lambda2 * mu1 * xi ^ 2) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * mu1 * xi ^ 3) + (12 * c * lambda1 * xi ^ 2) - (36 * c * lambda1 ^ 2 * mu1 * xi ^ 2) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda1 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 * mu2 * s2 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1 * xi) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi) + (144 * c * lambda1 * lambda2 * mu2 * xi) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2) + (72 * lambda1 * lambda2 ^ 2 * mu2) + (144 * lambda1 * lambda2 * mu2) + (12 * c * lambda1 ^ 2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3 + 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 + 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3 - 12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 + 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2 - 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda2 * s2 * xi ^ 3 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 12 * c * lambda1 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * s2 * xi ^ 3 + 36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 - 24 * c * lambda1 * lambda2 * mu1 * xi ^ 3 - 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 + 12 * c * lambda1 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 12 * c * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2 + 36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi - 24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda2 * s2 * xi ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi - 72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi + 72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 - 72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi - 12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * c * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * c * lambda1 * lambda2 * s2 * xi ^ 2 - 12 * c * lambda1 * mu1 * xi ^ 3 - 6 * c * lambda1 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * s2 * sigma * xi ^ 2 + 6 * c * lambda1 * s2 * xi ^ 3 + 36 * c * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 - 12 * c * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 + 6 * c * lambda2 * s2 * xi ^ 3 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi + 36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * xi ^ 3 * mu1 + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 + 36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 - 24 * lambda1 * lambda2 * mu1 * xi ^ 3 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 - 12 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 36 * c ^ 2 * lambda1 ^ 2 * lambda2 + 36 * c ^ 2 * lambda1 ^ 2 * xi - 36 * c ^ 2 * lambda1 * lambda2 ^ 2 + 72 * c ^ 2 * lambda1 * lambda2 * xi - 12 * c ^ 2 * lambda1 * xi ^ 2 + 36 * c ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda2 * xi ^ 2 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 + 72 * c * lambda1 ^ 2 * lambda2 * mu1 - 72 * c * lambda1 ^ 2 * lambda2 * mu2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 36 * c * lambda1 ^ 2 * lambda2 * xi - 72 * c * lambda1 ^ 2 * mu1 * xi + 72 * c * lambda1 ^ 2 * mu2 * xi + 6 * c * lambda1 ^ 2 * sigma * xi - 12 * c * lambda1 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 ^ 2 * mu1 - 72 * c * lambda1 * lambda2 ^ 2 * mu2 - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 36 * c * lambda1 * lambda2 ^ 2 * xi - 144 * c * lambda1 * lambda2 * mu1 * xi + 144 * c * lambda1 * lambda2 * mu2 * xi - 24 * c * lambda1 * lambda2 * xi ^ 2 + 36 * c * lambda1 * mu1 * xi ^ 2 - 24 * c * lambda1 * mu2 * xi ^ 2 - 6 * c * lambda1 * s2 * xi ^ 2 + 2 * c * lambda1 * sigma * xi ^ 2 - 72 * c * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda2 ^ 2 * sigma * xi - 12 * c * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda2 * s2 * xi ^ 2 + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 - 72 * lambda1 ^ 2 * lambda2 * mu1 * xi + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma + 72 * lambda1 ^ 2 * lambda2 * mu2 * xi + 36 * lambda1 ^ 2 * xi ^ 2 * mu1 - 12 * lambda1 ^ 2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * mu2 * xi ^ 2 - 72 * lambda1 * lambda2 ^ 2 * mu1 * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda1 * lambda2 ^ 2 * mu2 * xi + 24 * lambda1 * lambda2 * mu1 * sigma * xi + 72 * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 * mu1 * sigma * xi ^ 2 - 12 * lambda1 * mu1 * xi ^ 3 + 12 * lambda1 * mu2 * sigma * xi ^ 2 + 36 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda2 * mu1 * sigma * xi ^ 2 - 12 * lambda2 * mu1 * xi ^ 3 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 36 * c ^ 2 * lambda1 ^ 2 - 72 * c ^ 2 * lambda1 * lambda2 + 36 * c ^ 2 * lambda1 * xi - 36 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda2 * xi - 36 * c * lambda1 ^ 2 * lambda2 + 72 * c * lambda1 ^ 2 * mu1 - 72 * c * lambda1 ^ 2 * mu2 - 6 * c * lambda1 ^ 2 * sigma + 36 * c * lambda1 ^ 2 * xi - 36 * c * lambda1 * lambda2 ^ 2 + 144 * c * lambda1 * lambda2 * mu1 - 144 * c * lambda1 * lambda2 * mu2 + 72 * c * lambda1 * lambda2 * xi - 72 * c * lambda1 * mu1 * xi + 72 * c * lambda1 * mu2 * xi - 6 * c * lambda1 * sigma * xi - 12 * c * lambda1 * xi ^ 2 + 72 * c * lambda2 ^ 2 * mu1 - 72 * c * lambda2 ^ 2 * mu2 - 6 * c * lambda2 ^ 2 * sigma + 36 * c * lambda2 ^ 2 * xi - 72 * c * lambda2 * mu1 * xi + 72 * c * lambda2 * mu2 * xi - 6 * c * lambda2 * sigma * xi - 12 * c * lambda2 * xi ^ 2 + 72 * lambda1 ^ 2 * lambda2 * mu1 - 72 * lambda1 ^ 2 * lambda2 * mu2 - 72 * lambda1 ^ 2 * mu1 * xi + 12 * lambda1 ^ 2 * mu2 * sigma + 72 * lambda1 ^ 2 * mu2 * xi + 72 * lambda1 * lambda2 ^ 2 * mu1 - 72 * lambda1 * lambda2 ^ 2 * mu2 - 24 * lambda1 * lambda2 * mu1 * sigma - 144 * lambda1 * lambda2 * mu1 * xi + 48 * lambda1 * lambda2 * mu2 * sigma + 144 * lambda1 * lambda2 * mu2 * xi + 24 * lambda1 * mu1 * sigma * xi + 36 * lambda1 * mu1 * xi ^ 2 - 36 * lambda1 * mu2 * sigma * xi - 24 * lambda1 * mu2 * xi ^ 2 - 72 * lambda2 ^ 2 * mu1 * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda2 ^ 2 * mu2 * xi + 24 * lambda2 * mu1 * sigma * xi + 36 * lambda2 * mu1 * xi ^ 2 - 36 * lambda2 * mu2 * sigma * xi - 24 * lambda2 * mu2 * xi ^ 2 - 36 * c ^ 2 * lambda1 - 36 * c ^ 2 * lambda2 - 36 * c * lambda1 ^ 2 - 72 * c * lambda1 * lambda2 + 72 * c * lambda1 * mu1 - 72 * c * lambda1 * mu2 + 6 * c * lambda1 * sigma + 36 * c * lambda1 * xi - 36 * c * lambda2 ^ 2 + 72 * c * lambda2 * mu1 - 72 * c * lambda2 * mu2 + 6 * c * lambda2 * sigma + 36 * c * lambda2 * xi + 72 * lambda1 ^ 2 * mu1 - 72 * lambda1 ^ 2 * mu2 + 144 * lambda1 * lambda2 * mu1 - 144 * lambda1 * lambda2 * mu2 - 24 * lambda1 * mu1 * sigma - 72 * lambda1 * mu1 * xi + 36 * lambda1 * mu2 * sigma + 72 * lambda1 * mu2 * xi + 72 * lambda2 ^ 2 * mu1 - 72 * lambda2 ^ 2 * mu2 - 24 * lambda2 * mu1 * sigma - 72 * lambda2 * mu1 * xi + 36 * lambda2 * mu2 * sigma + 72 * lambda2 * mu2 * xi - 36 * c * lambda1 - 36 * c * lambda2 + 72 * lambda1 * mu1 - 72 * lambda1 * mu2 + 72 * lambda2 * mu1 - 72 * lambda2 * mu2) * exp((2 * xi))) / (-(12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi + 2 * c * lambda1 * s2 * sigma * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 6 * c * lambda1 ^ 2 * sigma * xi - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 2 * c * lambda1 * sigma * xi ^ 2 + 6 * c * lambda2 ^ 2 * sigma * xi + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma - 12 * lambda1 ^ 2 * mu2 * sigma * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda1 * lambda2 * mu1 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 12 * lambda1 * mu1 * sigma * xi ^ 2 + 12 * lambda1 * mu2 * sigma * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda2 * mu1 * sigma * xi ^ 2 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 6 * c * lambda1 ^ 2 * sigma - 6 * c * lambda1 * sigma * xi - 6 * c * lambda2 ^ 2 * sigma - 6 * c * lambda2 * sigma * xi + 12 * lambda1 ^ 2 * mu2 * sigma - 24 * lambda1 * lambda2 * mu1 * sigma + 48 * lambda1 * lambda2 * mu2 * sigma + 24 * lambda1 * mu1 * sigma * xi - 36 * lambda1 * mu2 * sigma * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda2 * mu1 * sigma * xi - 36 * lambda2 * mu2 * sigma * xi + 6 * c * lambda1 * sigma + 6 * c * lambda2 * sigma - 24 * lambda1 * mu1 * sigma + 36 * lambda1 * mu2 * sigma - 24 * lambda2 * mu1 * sigma + 36 * lambda2 * mu2 * sigma) * exp((2 * xi)) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) - (6 * c * lambda1 * sigma * xi) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi)) / 0.2e1;
   %x0=-(1/2)*(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1-6*alpha*c*l^3*mu1-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2+3*alpha^2*c^2*l*s2-3*alpha^2*l^3*mu1*mu2-3*alpha^2*l^2*mu1*mu2-6*l^3*mu1*mu2-6*l^2*mu1*mu2+9*c^2-alpha^3*l^3*mu1*mu2-alpha^3*l^2*mu1*mu2-6*alpha*l^3*mu1*mu2-6*alpha*l^2*mu1*mu2+3*alpha^2*c^2+9*c^2*l-18*c*mu1+9*alpha*c^2+3*c^2*l^2+alpha^2*c^2*l^2-6*c*l^3*mu1-12*c*l^2*mu1+6*c*l^2*mu2+3*alpha*c^2*l^2+6*alpha^2*c*l*mu2*s2-9*alpha^2*c*l*mu1+6*alpha^2*c*l*mu2+6*alpha^2*c*mu2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-18*alpha*c*l*mu1+18*alpha*c*l*mu2-18*alpha*c*mu1+18*alpha*c*mu2+18*mu2*c+3*alpha^2*c^2*l+3*alpha^2*c^2*s2-9*alpha^2*c*mu1+6*alpha^2*c*mu2-18*c*l*mu1+18*c*l*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*mu1+9*alpha*c^2*l+(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+2*alpha^3*c*l^2*mu2*s2-alpha^3*l^3*mu1*mu2+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1+6*alpha^3*c*l*mu2*s2-alpha^3*l^2*mu1*mu2-alpha^2*c^2*l^2*s2+3*alpha^2*c*l^3*mu1-2*alpha^2*c*l^2*mu2*s2+3*alpha^2*l^3*mu1*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-alpha^2*c^2*l^2-3*alpha^2*c^2*l*s2+6*alpha^2*c*l^2*mu1-2*alpha^2*c*l^2*mu2-6*alpha^2*c*l*mu2*s2+3*alpha^2*l^2*mu1*mu2-6*alpha*c*l^3*mu1-6*alpha*l^3*mu1*mu2-3*alpha^3*c*mu1-3*alpha^2*c^2*l-3*alpha^2*c^2*s2+9*alpha^2*c*l*mu1-6*alpha^2*c*l*mu2-6*alpha^2*c*mu2*s2+3*alpha*c^2*l^2-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2-6*alpha*l^2*mu1*mu2+6*c*l^3*mu1+6*l^3*mu1*mu2-3*alpha^2*c^2+9*alpha^2*c*mu1-6*alpha^2*c*mu2+9*alpha*c^2*l-18*alpha*c*l*mu1+18*alpha*c*l*mu2-3*c^2*l^2+12*c*l^2*mu1-6*c*l^2*mu2+6*l^2*mu1*mu2+9*alpha*c^2-18*alpha*c*mu1+18*alpha*c*mu2-9*c^2*l+18*c*l*mu1-18*c*l*mu2-9*c^2+18*c*mu1-18*c*mu2)*exp(2*alpha)+2*alpha^2*c*l^2*mu2*s2+2*alpha^3*c*l^2*mu2*s2+6*alpha^3*c*l*mu2*s2+alpha^2*c^2*l^2*s2-3*alpha^2*c*l^3*mu1-6*alpha^2*c*l^2*mu1+2*alpha^2*c*l^2*mu2)/(l^2*((alpha^3*c^2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+2*alpha^3*l*mu1*mu2+alpha^3*c*mu1+2*alpha^3*mu1*mu2+3*alpha^2*c^2*l-alpha^2*c^2*s2-6*alpha^2*c*l*mu1+9*alpha^2*c*l*mu2-2*alpha^2*c*mu2*s2-6*alpha^2*l*mu1*mu2+6*alpha^2*l*mu2^2+2*alpha^2*c^2-3*alpha^2*c*mu1+7*alpha^2*c*mu2-6*alpha^2*mu1*mu2+6*alpha^2*mu2^2-9*alpha*c^2*l+12*alpha*c*l*mu1-27*alpha*c*l*mu2+12*alpha*l*mu1*mu2-18*alpha*l*mu2^2-6*alpha*c^2+6*alpha*c*mu1-21*alpha*c*mu2+12*alpha*mu1*mu2-18*alpha*mu2^2+9*c^2*l-12*c*l*mu1+27*c*l*mu2-12*l*mu1*mu2+18*l*mu2^2+6*c^2-6*c*mu1+21*c*mu2-12*mu1*mu2+18*mu2^2)*exp(2*alpha)-6*alpha^2*l*mu2^2+6*alpha^2*mu1*mu2+12*l*mu1*mu2-6*alpha^2*mu2^2-18*l*mu2^2+12*mu1*mu2-6*c^2+2*alpha^3*l*mu1*mu2+12*alpha*l*mu1*mu2-2*alpha^2*c^2-9*c^2*l+6*c*mu1-6*alpha*c^2-18*alpha*mu2^2+2*alpha^3*mu1*mu2-18*alpha*l*mu2^2+12*alpha*mu1*mu2+6*alpha^2*l*mu1*mu2+6*alpha^2*c*l*mu1-9*alpha^2*c*l*mu2+2*alpha^2*c*mu2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+12*alpha*c*l*mu1-27*alpha*c*l*mu2+6*alpha*c*mu1-21*alpha*c*mu2-21*mu2*c-18*mu2^2-3*alpha^2*c^2*l+alpha^2*c^2*s2+3*alpha^2*c*mu1-7*alpha^2*c*mu2+12*c*l*mu1-27*c*l*mu2+alpha^3*c^2*s2+alpha^3*c*mu1-9*alpha*c^2*l));
  
   %val =(3/(4*pi*sigma^2*(rho1-1 -3*x1)))/(1/(2*(2+c)*pi*x0));
   val = 3/(4*pi*sigma^2*(rho1-1 -3*x1));
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function steady = normalize(p)
    s1 = p.s1; alpha=p.alpha; 
    s2 = p.s2; c = p.c; j = p.j; rho1 = p.rho1; 
    mu2=p.mu2; mu1=p.mu1;
    l = sqrt(c*s1*(2+c)/(1+c));
    x0=-(1/2)*(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1-6*alpha*c*l^3*mu1-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2+3*alpha^2*c^2*l*s2-3*alpha^2*l^3*mu1*mu2-3*alpha^2*l^2*mu1*mu2-6*l^3*mu1*mu2-6*l^2*mu1*mu2+9*c^2-alpha^3*l^3*mu1*mu2-alpha^3*l^2*mu1*mu2-6*alpha*l^3*mu1*mu2-6*alpha*l^2*mu1*mu2+3*alpha^2*c^2+9*c^2*l-18*c*mu1+9*alpha*c^2+3*c^2*l^2+alpha^2*c^2*l^2-6*c*l^3*mu1-12*c*l^2*mu1+6*c*l^2*mu2+3*alpha*c^2*l^2+6*alpha^2*c*l*mu2*s2-9*alpha^2*c*l*mu1+6*alpha^2*c*l*mu2+6*alpha^2*c*mu2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-18*alpha*c*l*mu1+18*alpha*c*l*mu2-18*alpha*c*mu1+18*alpha*c*mu2+18*mu2*c+3*alpha^2*c^2*l+3*alpha^2*c^2*s2-9*alpha^2*c*mu1+6*alpha^2*c*mu2-18*c*l*mu1+18*c*l*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*mu1+9*alpha*c^2*l+(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+2*alpha^3*c*l^2*mu2*s2-alpha^3*l^3*mu1*mu2+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1+6*alpha^3*c*l*mu2*s2-alpha^3*l^2*mu1*mu2-alpha^2*c^2*l^2*s2+3*alpha^2*c*l^3*mu1-2*alpha^2*c*l^2*mu2*s2+3*alpha^2*l^3*mu1*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-alpha^2*c^2*l^2-3*alpha^2*c^2*l*s2+6*alpha^2*c*l^2*mu1-2*alpha^2*c*l^2*mu2-6*alpha^2*c*l*mu2*s2+3*alpha^2*l^2*mu1*mu2-6*alpha*c*l^3*mu1-6*alpha*l^3*mu1*mu2-3*alpha^3*c*mu1-3*alpha^2*c^2*l-3*alpha^2*c^2*s2+9*alpha^2*c*l*mu1-6*alpha^2*c*l*mu2-6*alpha^2*c*mu2*s2+3*alpha*c^2*l^2-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2-6*alpha*l^2*mu1*mu2+6*c*l^3*mu1+6*l^3*mu1*mu2-3*alpha^2*c^2+9*alpha^2*c*mu1-6*alpha^2*c*mu2+9*alpha*c^2*l-18*alpha*c*l*mu1+18*alpha*c*l*mu2-3*c^2*l^2+12*c*l^2*mu1-6*c*l^2*mu2+6*l^2*mu1*mu2+9*alpha*c^2-18*alpha*c*mu1+18*alpha*c*mu2-9*c^2*l+18*c*l*mu1-18*c*l*mu2-9*c^2+18*c*mu1-18*c*mu2)*exp(2*alpha)+2*alpha^2*c*l^2*mu2*s2+2*alpha^3*c*l^2*mu2*s2+6*alpha^3*c*l*mu2*s2+alpha^2*c^2*l^2*s2-3*alpha^2*c*l^3*mu1-6*alpha^2*c*l^2*mu1+2*alpha^2*c*l^2*mu2)/(l^2*((alpha^3*c^2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+2*alpha^3*l*mu1*mu2+alpha^3*c*mu1+2*alpha^3*mu1*mu2+3*alpha^2*c^2*l-alpha^2*c^2*s2-6*alpha^2*c*l*mu1+9*alpha^2*c*l*mu2-2*alpha^2*c*mu2*s2-6*alpha^2*l*mu1*mu2+6*alpha^2*l*mu2^2+2*alpha^2*c^2-3*alpha^2*c*mu1+7*alpha^2*c*mu2-6*alpha^2*mu1*mu2+6*alpha^2*mu2^2-9*alpha*c^2*l+12*alpha*c*l*mu1-27*alpha*c*l*mu2+12*alpha*l*mu1*mu2-18*alpha*l*mu2^2-6*alpha*c^2+6*alpha*c*mu1-21*alpha*c*mu2+12*alpha*mu1*mu2-18*alpha*mu2^2+9*c^2*l-12*c*l*mu1+27*c*l*mu2-12*l*mu1*mu2+18*l*mu2^2+6*c^2-6*c*mu1+21*c*mu2-12*mu1*mu2+18*mu2^2)*exp(2*alpha)-6*alpha^2*l*mu2^2+6*alpha^2*mu1*mu2+12*l*mu1*mu2-6*alpha^2*mu2^2-18*l*mu2^2+12*mu1*mu2-6*c^2+2*alpha^3*l*mu1*mu2+12*alpha*l*mu1*mu2-2*alpha^2*c^2-9*c^2*l+6*c*mu1-6*alpha*c^2-18*alpha*mu2^2+2*alpha^3*mu1*mu2-18*alpha*l*mu2^2+12*alpha*mu1*mu2+6*alpha^2*l*mu1*mu2+6*alpha^2*c*l*mu1-9*alpha^2*c*l*mu2+2*alpha^2*c*mu2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+12*alpha*c*l*mu1-27*alpha*c*l*mu2+6*alpha*c*mu1-21*alpha*c*mu2-21*mu2*c-18*mu2^2-3*alpha^2*c^2*l+alpha^2*c^2*s2+3*alpha^2*c*mu1-7*alpha^2*c*mu2+12*c*l*mu1-27*c*l*mu2+alpha^3*c^2*s2+alpha^3*c*mu1-9*alpha*c^2*l));
    steady = (1/(2*(2+c)*pi*x0));
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function ilt = talbot_inversion(F, t, M)
    % TALBOT_INVERSION
    % Numerical inverse Laplace transform using the fixed Talbot method
    %
    % ilt = talbot_inversion(F, t, M)
    %
    % Inputs:
    %   F : function handle representing F(s)
    %   t : scalar or vector of positive time values
    %   M : number of Talbot terms, default = 64
    %
    % Output:
    %   ilt : numerical inverse Laplace transform at t

    % Default number of terms
    if nargin < 3
        M = 64;
    end

    % Preserve the original shape of t
    original_size = size(t);

    % Convert t to a column vector
    t = t(:);

    % Check that all time values are positive
    if any(t <= 0)
        error('All time values must be positive.');
    end

    % Preallocate result
    ilt = zeros(length(t), 1);

    % Talbot contour angles
    k = 1:(M-1);
    theta = (pi/M) * k;
    cot_theta = cot(theta);

    % Talbot contour parameters
    delta = zeros(1, M);

    % Correct first contour point
    delta(1) = 2*M/5;

    delta(2:end) = ...
        (2*M/5) * theta .* (cot_theta + 1i);

    % Talbot weights
    gamma = zeros(1, M);

    gamma(1) = 0.5 * exp(delta(1));

    gamma(2:end) = ...
        (1 ...
        + 1i*theta.*(1 + cot_theta.^2) ...
        - 1i*cot_theta) ...
        .* exp(delta(2:end));

    % Evaluate the inverse transform
    for i = 1:length(t)

        s_vals = delta / t(i);

        f_vals = arrayfun(F, s_vals);

        ilt(i) = ...
            (0.4/t(i)) * sum(real(gamma .* f_vals));

    end

    % Restore original shape
    ilt = reshape(ilt, original_size);

end

[dpb]

Well, again, one has to verify the assumptions being made; ergo, first off is the SS value actually a constant and does it match what would be empirically expected?

I modified the function to return the two parts of the ratio independently and plotted the pieces again...the SS value (denominator) is again dependent upon time and is quite small in amplitude.

Of course, when one does the inverse on these individually, it isn't the same but what this shows is that the computed inverse of the internal ratio is almost unchanged form the value if only evaluate the numerator (top plot).

The middle plot shows what the denominator inverse on its own is; again it is not time-invariant so it can't represent the SS.

And, for the plotting in the time domain that you're looking for, anyway, the SS value needs to be what the time trace value will approach as t-->inf.

This functional at least does seem to have solved the large time problem, but now each appears to reach its own SS instead of the prior where all cases did approach a common SS value before the inversion blew up. Looks like this case could be solved by computing the SS value for each as suggested before; again, that would a a different value for each but then could create the normalized plot.

sh1()

function sh1()
  t_values = logspace(0, 5, 500);
  c_vals = [1, 4, 6, 10]; % 4 specific curves to compare
  params = struct('s1',2, 'rho1',0,'s2',0, 'alpha',1, 'j',0.1,'mu1',1,'mu2',0.001,'out','');
  %figure; hold on;
  for ii=1:3, hAx(ii)=subplot(3,1,ii);end  % make three axes so can plot pieces, too
  colors = ['r', 'g', 'b', 'm']; % 4 colors for the three curves
  labels={'U_{uns}','U_{std}','Ratio'};
  % Steady-state velocity for this value of c
  for k = 1:length(c_vals)
    params.c = c_vals(k);
    u_s1 = zeros(size(t_values));
    for i = 1:length(t_values)
      % Compute Numerator/denominator at the current c
      params.out='num';
      u_s1(i,1)=talbot_inversion(@(sigma) U_func_s1(sigma, params), t_values(i));
      params.out='den';
      u_s1(i,2)=talbot_inversion(@(sigma) U_func_s1(sigma, params), t_values(i));
    end
    % Calculate ratio
    num=u_s1(:,1); den=u_s1(:,2);   % numerator and denominator, temporaries
    ratio=num./den;
    % Plot
    %plot(t_values, ratio, 'Color', colors(k), 'LineWidth', 2, ...
    %    'DisplayName', sprintf('c=%.2f', c_vals(k)));
    semilogx(hAx(1),t_values,num,  'Color',colors(k),'LineWidth', 2,'DisplayName', sprintf('c=%.2f', c_vals(k)));
    semilogx(hAx(2),t_values,den,  'Color',colors(k),'LineWidth', 2,'DisplayName', sprintf('c=%.2f', c_vals(k)));
    semilogx(hAx(3),t_values,ratio,'Color',colors(k),'LineWidth', 2,'DisplayName', sprintf('c=%.2f', c_vals(k)));
    if k==1, hold(hAx,'on'); end        % to add more to each axis
  end
  for k=1:3
    xlabel(hAx(k),'Time (t)'); ylabel(hAx(k),labels(k));
    legend(hAx(k),'Location', 'best'); grid on;
  end
%    title('Effect of Micropolar Coupling on Dispersion Ratio');
end

% --- Rename your existing logic to avoid conflicts ---
function val = U_func_s1(sigma, p)
    % Copy your logic from the original calc_s1.m U_function here
    % Ensure it returns 'val'
    % Unpack1
    s1 = p.s1; alpha=p.alpha; 
    s2 = p.s2; c = p.c; j = p.j; rho1 = p.rho1; 
    mu2=p.mu2; mu1=p.mu1;
    out=matches(p.out,'num');               % T-->num, F-->den
    % Define S (sum) and P (product)
    xi=sqrt(alpha^2+sigma);
    l = sqrt(c*s1*(2+c)/(1+c));
    % Calculate roots
    S0 = l^2 + (sigma * (1 + j * s1 * (1 + c))) / (1 + c);
    P0 = (sigma * s1 * (4 * c + j * sigma)) / (1 + c);  
    lambda1 = sqrt((S0 - sqrt(S0^2 - 4*P0)) / 2);
    lambda2 = sqrt((S0 + sqrt(S0^2 - 4*P0)) / 2);
   x1 = -(-(72 * lambda1 ^ 2 * lambda2 * mu1) - (72 * lambda1 * lambda2 ^ 2 * mu1) - (36 * lambda1 * mu1 * xi ^ 2) + (24 * lambda1 * mu2 * xi ^ 2) - (36 * lambda2 * mu1 * xi ^ 2) + (24 * lambda2 * mu2 * xi ^ 2) + (72 * c * lambda1 * lambda2 * xi) + (12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) - (72 * c * lambda2 * mu1) + (72 * c * lambda2 * mu2) + (72 * c * lambda1 * mu2) - (72 * c * lambda2 ^ 2 * mu1) + (72 * c * lambda2 ^ 2 * mu2) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (36 * c ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (72 * lambda2 * mu1) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (24 * lambda1 * lambda2 * mu1 * xi ^ 3) - (144 * lambda1 * lambda2 * mu1) - (72 * lambda1 ^ 2 * mu1) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (12 * c * lambda2 * mu1 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * lambda1 * mu1 * xi ^ 3) - (12 * lambda2 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2) + (72 * lambda2 ^ 2 * mu2) + (72 * lambda1 * mu2) + (72 * lambda2 * mu2) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) - (24 * c * lambda1 * lambda2 * mu1 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1) + (72 * c * lambda1 ^ 2 * mu2) + (144 * c * lambda1 * lambda2 * mu2) + (36 * c ^ 2 * lambda1 ^ 2 * xi) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2) + (12 * c ^ 2 * lambda1 * xi ^ 2) + (12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda2 * xi ^ 2) + (36 * c * lambda1 * xi) + (36 * c * lambda2 * xi) + (36 * c ^ 2 * lambda2) + (36 * c ^ 2 * lambda1) + (24 * c * lambda1 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 3) + (36 * c ^ 2 * lambda1 ^ 2) + (36 * c ^ 2 * lambda2 ^ 2) + (72 * c ^ 2 * lambda1 * lambda2) + (36 * c * lambda2 ^ 2) + (36 * c * lambda1) + (36 * c * lambda2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (6 * c * lambda1 * s2 * xi ^ 3) + (6 * c * lambda2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 2) + (72 * c ^ 2 * lambda1 * lambda2 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2) - (36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) - (72 * lambda2 ^ 2 * mu1 * xi) + (72 * lambda2 ^ 2 * mu2 * xi) - (12 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * c * lambda2 * mu1 * xi) + (72 * c * lambda2 * mu2 * xi) - (144 * c * lambda1 * lambda2 * mu1) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2) - (36 * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * lambda2 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) - (144 * lambda1 * lambda2 * mu1 * xi) + (144 * lambda1 * lambda2 * mu2 * xi) + (72 * lambda1 * lambda2 ^ 2 * mu2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * lambda1 * lambda2 ^ 2 * mu1 * xi) - (72 * lambda1 ^ 2 * lambda2 * mu1 * xi) + (36 * c * lambda1 ^ 2 * lambda2) + (36 * c * lambda1 * lambda2 ^ 2) + (72 * c * lambda1 * lambda2) - (36 * c * lambda2 * mu1 * xi ^ 2) + (24 * c * lambda2 * mu2 * xi ^ 2) + (24 * c * lambda1 * mu2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2) - (72 * c * lambda1 * lambda2 ^ 2 * mu1) - (72 * c * lambda1 ^ 2 * lambda2 * mu1) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) - (72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi) - (72 * lambda1 * mu1 * xi) + (72 * lambda1 * mu2 * xi) - (72 * lambda2 * mu1 * xi) + (72 * lambda2 * mu2 * xi) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * lambda1 ^ 2 * xi ^ 3 * mu1) - (36 * lambda1 ^ 2 * xi ^ 2 * mu1) - (72 * lambda1 ^ 2 * mu1 * xi) + (24 * lambda1 ^ 2 * mu2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2) - (36 * c * lambda1 * mu1 * xi ^ 2) + (48 * c * lambda1 * lambda2 * mu2 * xi ^ 2) - (144 * c * lambda1 * lambda2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (36 * c ^ 2 * lambda1 * xi) + (36 * c ^ 2 * lambda2 * xi) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 2) - (12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * lambda1 * mu1) - (72 * lambda2 ^ 2 * mu1) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (36 * c * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * c * lambda2 ^ 2 * mu2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * lambda2 * xi) + (36 * c * lambda1 * lambda2 ^ 2 * xi) - (72 * c * lambda2 ^ 2 * mu1 * xi) + (72 * c * lambda2 ^ 2 * mu2 * xi) + (6 * c * lambda1 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 * mu2 * s2 * xi ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) - (12 * c * lambda2 ^ 2 * mu1 * xi ^ 3) + (12 * c ^ 2 * lambda2 * xi ^ 2) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 3) - (6 * c * lambda1 * sigma * xi) - (72 * c * lambda1 * mu1) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2) - (72 * c * lambda1 * mu1 * xi) + (72 * c * lambda1 * mu2 * xi) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) + (72 * c * lambda1 ^ 2 * mu2 * xi) + (36 * c * lambda1 ^ 2) + (24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2) + (24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) - (72 * lambda1 * lambda2 * mu1 * xi ^ 2) + (48 * lambda1 * lambda2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) - (12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (24 * c * lambda1 * lambda2 * xi ^ 2) + (6 * c * lambda1 * s2 * xi ^ 2) + (6 * c * lambda2 * s2 * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi) - (12 * c * lambda1 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (12 * c * lambda2 ^ 2 * xi ^ 2) + (36 * c * lambda2 ^ 2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi) - (72 * c * lambda1 * lambda2 * mu1 * xi ^ 2) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * mu1 * xi ^ 3) + (12 * c * lambda1 * xi ^ 2) - (36 * c * lambda1 ^ 2 * mu1 * xi ^ 2) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda1 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 * mu2 * s2 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1 * xi) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi) + (144 * c * lambda1 * lambda2 * mu2 * xi) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2) + (72 * lambda1 * lambda2 ^ 2 * mu2) + (144 * lambda1 * lambda2 * mu2) + (12 * c * lambda1 ^ 2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3 + 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 + 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3 - 12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 + 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2 - 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda2 * s2 * xi ^ 3 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 12 * c * lambda1 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * s2 * xi ^ 3 + 36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 - 24 * c * lambda1 * lambda2 * mu1 * xi ^ 3 - 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 + 12 * c * lambda1 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 12 * c * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2 + 36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi - 24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda2 * s2 * xi ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi - 72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi + 72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 - 72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi - 12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * c * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * c * lambda1 * lambda2 * s2 * xi ^ 2 - 12 * c * lambda1 * mu1 * xi ^ 3 - 6 * c * lambda1 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * s2 * sigma * xi ^ 2 + 6 * c * lambda1 * s2 * xi ^ 3 + 36 * c * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 - 12 * c * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 + 6 * c * lambda2 * s2 * xi ^ 3 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi + 36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * xi ^ 3 * mu1 + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 + 36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 - 24 * lambda1 * lambda2 * mu1 * xi ^ 3 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 - 12 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 36 * c ^ 2 * lambda1 ^ 2 * lambda2 + 36 * c ^ 2 * lambda1 ^ 2 * xi - 36 * c ^ 2 * lambda1 * lambda2 ^ 2 + 72 * c ^ 2 * lambda1 * lambda2 * xi - 12 * c ^ 2 * lambda1 * xi ^ 2 + 36 * c ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda2 * xi ^ 2 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 + 72 * c * lambda1 ^ 2 * lambda2 * mu1 - 72 * c * lambda1 ^ 2 * lambda2 * mu2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 36 * c * lambda1 ^ 2 * lambda2 * xi - 72 * c * lambda1 ^ 2 * mu1 * xi + 72 * c * lambda1 ^ 2 * mu2 * xi + 6 * c * lambda1 ^ 2 * sigma * xi - 12 * c * lambda1 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 ^ 2 * mu1 - 72 * c * lambda1 * lambda2 ^ 2 * mu2 - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 36 * c * lambda1 * lambda2 ^ 2 * xi - 144 * c * lambda1 * lambda2 * mu1 * xi + 144 * c * lambda1 * lambda2 * mu2 * xi - 24 * c * lambda1 * lambda2 * xi ^ 2 + 36 * c * lambda1 * mu1 * xi ^ 2 - 24 * c * lambda1 * mu2 * xi ^ 2 - 6 * c * lambda1 * s2 * xi ^ 2 + 2 * c * lambda1 * sigma * xi ^ 2 - 72 * c * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda2 ^ 2 * sigma * xi - 12 * c * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda2 * s2 * xi ^ 2 + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 - 72 * lambda1 ^ 2 * lambda2 * mu1 * xi + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma + 72 * lambda1 ^ 2 * lambda2 * mu2 * xi + 36 * lambda1 ^ 2 * xi ^ 2 * mu1 - 12 * lambda1 ^ 2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * mu2 * xi ^ 2 - 72 * lambda1 * lambda2 ^ 2 * mu1 * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda1 * lambda2 ^ 2 * mu2 * xi + 24 * lambda1 * lambda2 * mu1 * sigma * xi + 72 * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 * mu1 * sigma * xi ^ 2 - 12 * lambda1 * mu1 * xi ^ 3 + 12 * lambda1 * mu2 * sigma * xi ^ 2 + 36 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda2 * mu1 * sigma * xi ^ 2 - 12 * lambda2 * mu1 * xi ^ 3 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 36 * c ^ 2 * lambda1 ^ 2 - 72 * c ^ 2 * lambda1 * lambda2 + 36 * c ^ 2 * lambda1 * xi - 36 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda2 * xi - 36 * c * lambda1 ^ 2 * lambda2 + 72 * c * lambda1 ^ 2 * mu1 - 72 * c * lambda1 ^ 2 * mu2 - 6 * c * lambda1 ^ 2 * sigma + 36 * c * lambda1 ^ 2 * xi - 36 * c * lambda1 * lambda2 ^ 2 + 144 * c * lambda1 * lambda2 * mu1 - 144 * c * lambda1 * lambda2 * mu2 + 72 * c * lambda1 * lambda2 * xi - 72 * c * lambda1 * mu1 * xi + 72 * c * lambda1 * mu2 * xi - 6 * c * lambda1 * sigma * xi - 12 * c * lambda1 * xi ^ 2 + 72 * c * lambda2 ^ 2 * mu1 - 72 * c * lambda2 ^ 2 * mu2 - 6 * c * lambda2 ^ 2 * sigma + 36 * c * lambda2 ^ 2 * xi - 72 * c * lambda2 * mu1 * xi + 72 * c * lambda2 * mu2 * xi - 6 * c * lambda2 * sigma * xi - 12 * c * lambda2 * xi ^ 2 + 72 * lambda1 ^ 2 * lambda2 * mu1 - 72 * lambda1 ^ 2 * lambda2 * mu2 - 72 * lambda1 ^ 2 * mu1 * xi + 12 * lambda1 ^ 2 * mu2 * sigma + 72 * lambda1 ^ 2 * mu2 * xi + 72 * lambda1 * lambda2 ^ 2 * mu1 - 72 * lambda1 * lambda2 ^ 2 * mu2 - 24 * lambda1 * lambda2 * mu1 * sigma - 144 * lambda1 * lambda2 * mu1 * xi + 48 * lambda1 * lambda2 * mu2 * sigma + 144 * lambda1 * lambda2 * mu2 * xi + 24 * lambda1 * mu1 * sigma * xi + 36 * lambda1 * mu1 * xi ^ 2 - 36 * lambda1 * mu2 * sigma * xi - 24 * lambda1 * mu2 * xi ^ 2 - 72 * lambda2 ^ 2 * mu1 * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda2 ^ 2 * mu2 * xi + 24 * lambda2 * mu1 * sigma * xi + 36 * lambda2 * mu1 * xi ^ 2 - 36 * lambda2 * mu2 * sigma * xi - 24 * lambda2 * mu2 * xi ^ 2 - 36 * c ^ 2 * lambda1 - 36 * c ^ 2 * lambda2 - 36 * c * lambda1 ^ 2 - 72 * c * lambda1 * lambda2 + 72 * c * lambda1 * mu1 - 72 * c * lambda1 * mu2 + 6 * c * lambda1 * sigma + 36 * c * lambda1 * xi - 36 * c * lambda2 ^ 2 + 72 * c * lambda2 * mu1 - 72 * c * lambda2 * mu2 + 6 * c * lambda2 * sigma + 36 * c * lambda2 * xi + 72 * lambda1 ^ 2 * mu1 - 72 * lambda1 ^ 2 * mu2 + 144 * lambda1 * lambda2 * mu1 - 144 * lambda1 * lambda2 * mu2 - 24 * lambda1 * mu1 * sigma - 72 * lambda1 * mu1 * xi + 36 * lambda1 * mu2 * sigma + 72 * lambda1 * mu2 * xi + 72 * lambda2 ^ 2 * mu1 - 72 * lambda2 ^ 2 * mu2 - 24 * lambda2 * mu1 * sigma - 72 * lambda2 * mu1 * xi + 36 * lambda2 * mu2 * sigma + 72 * lambda2 * mu2 * xi - 36 * c * lambda1 - 36 * c * lambda2 + 72 * lambda1 * mu1 - 72 * lambda1 * mu2 + 72 * lambda2 * mu1 - 72 * lambda2 * mu2) * exp((2 * xi))) / (-(12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi + 2 * c * lambda1 * s2 * sigma * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 6 * c * lambda1 ^ 2 * sigma * xi - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 2 * c * lambda1 * sigma * xi ^ 2 + 6 * c * lambda2 ^ 2 * sigma * xi + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma - 12 * lambda1 ^ 2 * mu2 * sigma * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda1 * lambda2 * mu1 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 12 * lambda1 * mu1 * sigma * xi ^ 2 + 12 * lambda1 * mu2 * sigma * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda2 * mu1 * sigma * xi ^ 2 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 6 * c * lambda1 ^ 2 * sigma - 6 * c * lambda1 * sigma * xi - 6 * c * lambda2 ^ 2 * sigma - 6 * c * lambda2 * sigma * xi + 12 * lambda1 ^ 2 * mu2 * sigma - 24 * lambda1 * lambda2 * mu1 * sigma + 48 * lambda1 * lambda2 * mu2 * sigma + 24 * lambda1 * mu1 * sigma * xi - 36 * lambda1 * mu2 * sigma * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda2 * mu1 * sigma * xi - 36 * lambda2 * mu2 * sigma * xi + 6 * c * lambda1 * sigma + 6 * c * lambda2 * sigma - 24 * lambda1 * mu1 * sigma + 36 * lambda1 * mu2 * sigma - 24 * lambda2 * mu1 * sigma + 36 * lambda2 * mu2 * sigma) * exp((2 * xi)) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) - (6 * c * lambda1 * sigma * xi) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi)) / 0.2e1;
   x0=-(1/2)*(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1-6*alpha*c*l^3*mu1-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2+3*alpha^2*c^2*l*s2-3*alpha^2*l^3*mu1*mu2-3*alpha^2*l^2*mu1*mu2-6*l^3*mu1*mu2-6*l^2*mu1*mu2+9*c^2-alpha^3*l^3*mu1*mu2-alpha^3*l^2*mu1*mu2-6*alpha*l^3*mu1*mu2-6*alpha*l^2*mu1*mu2+3*alpha^2*c^2+9*c^2*l-18*c*mu1+9*alpha*c^2+3*c^2*l^2+alpha^2*c^2*l^2-6*c*l^3*mu1-12*c*l^2*mu1+6*c*l^2*mu2+3*alpha*c^2*l^2+6*alpha^2*c*l*mu2*s2-9*alpha^2*c*l*mu1+6*alpha^2*c*l*mu2+6*alpha^2*c*mu2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-18*alpha*c*l*mu1+18*alpha*c*l*mu2-18*alpha*c*mu1+18*alpha*c*mu2+18*mu2*c+3*alpha^2*c^2*l+3*alpha^2*c^2*s2-9*alpha^2*c*mu1+6*alpha^2*c*mu2-18*c*l*mu1+18*c*l*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*mu1+9*alpha*c^2*l+(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+2*alpha^3*c*l^2*mu2*s2-alpha^3*l^3*mu1*mu2+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1+6*alpha^3*c*l*mu2*s2-alpha^3*l^2*mu1*mu2-alpha^2*c^2*l^2*s2+3*alpha^2*c*l^3*mu1-2*alpha^2*c*l^2*mu2*s2+3*alpha^2*l^3*mu1*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-alpha^2*c^2*l^2-3*alpha^2*c^2*l*s2+6*alpha^2*c*l^2*mu1-2*alpha^2*c*l^2*mu2-6*alpha^2*c*l*mu2*s2+3*alpha^2*l^2*mu1*mu2-6*alpha*c*l^3*mu1-6*alpha*l^3*mu1*mu2-3*alpha^3*c*mu1-3*alpha^2*c^2*l-3*alpha^2*c^2*s2+9*alpha^2*c*l*mu1-6*alpha^2*c*l*mu2-6*alpha^2*c*mu2*s2+3*alpha*c^2*l^2-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2-6*alpha*l^2*mu1*mu2+6*c*l^3*mu1+6*l^3*mu1*mu2-3*alpha^2*c^2+9*alpha^2*c*mu1-6*alpha^2*c*mu2+9*alpha*c^2*l-18*alpha*c*l*mu1+18*alpha*c*l*mu2-3*c^2*l^2+12*c*l^2*mu1-6*c*l^2*mu2+6*l^2*mu1*mu2+9*alpha*c^2-18*alpha*c*mu1+18*alpha*c*mu2-9*c^2*l+18*c*l*mu1-18*c*l*mu2-9*c^2+18*c*mu1-18*c*mu2)*exp(2*alpha)+2*alpha^2*c*l^2*mu2*s2+2*alpha^3*c*l^2*mu2*s2+6*alpha^3*c*l*mu2*s2+alpha^2*c^2*l^2*s2-3*alpha^2*c*l^3*mu1-6*alpha^2*c*l^2*mu1+2*alpha^2*c*l^2*mu2)/(l^2*((alpha^3*c^2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+2*alpha^3*l*mu1*mu2+alpha^3*c*mu1+2*alpha^3*mu1*mu2+3*alpha^2*c^2*l-alpha^2*c^2*s2-6*alpha^2*c*l*mu1+9*alpha^2*c*l*mu2-2*alpha^2*c*mu2*s2-6*alpha^2*l*mu1*mu2+6*alpha^2*l*mu2^2+2*alpha^2*c^2-3*alpha^2*c*mu1+7*alpha^2*c*mu2-6*alpha^2*mu1*mu2+6*alpha^2*mu2^2-9*alpha*c^2*l+12*alpha*c*l*mu1-27*alpha*c*l*mu2+12*alpha*l*mu1*mu2-18*alpha*l*mu2^2-6*alpha*c^2+6*alpha*c*mu1-21*alpha*c*mu2+12*alpha*mu1*mu2-18*alpha*mu2^2+9*c^2*l-12*c*l*mu1+27*c*l*mu2-12*l*mu1*mu2+18*l*mu2^2+6*c^2-6*c*mu1+21*c*mu2-12*mu1*mu2+18*mu2^2)*exp(2*alpha)-6*alpha^2*l*mu2^2+6*alpha^2*mu1*mu2+12*l*mu1*mu2-6*alpha^2*mu2^2-18*l*mu2^2+12*mu1*mu2-6*c^2+2*alpha^3*l*mu1*mu2+12*alpha*l*mu1*mu2-2*alpha^2*c^2-9*c^2*l+6*c*mu1-6*alpha*c^2-18*alpha*mu2^2+2*alpha^3*mu1*mu2-18*alpha*l*mu2^2+12*alpha*mu1*mu2+6*alpha^2*l*mu1*mu2+6*alpha^2*c*l*mu1-9*alpha^2*c*l*mu2+2*alpha^2*c*mu2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+12*alpha*c*l*mu1-27*alpha*c*l*mu2+6*alpha*c*mu1-21*alpha*c*mu2-21*mu2*c-18*mu2^2-3*alpha^2*c^2*l+alpha^2*c^2*s2+3*alpha^2*c*mu1-7*alpha^2*c*mu2+12*c*l*mu1-27*c*l*mu2+alpha^3*c^2*s2+alpha^3*c*mu1-9*alpha*c^2*l));
   %val =(3/(4*pi*sigma^2*(rho1-1 -3*x1)))/(1/(2*(2+c)*pi*x0));
   % return num, den on request
   if out
     val=(3/(4*pi*sigma^2*(rho1-1 -3*x1)));
   else
     val=(1/(2*(2+c)*pi*x0));
   end
end

function ilt = talbot_inversion(F, t, M)
    % TALBOT_INVERSION
    % Numerical inverse Laplace transform using the fixed Talbot method
    %
    % ilt = talbot_inversion(F, t, M)
    %
    % Inputs:
    %   F : function handle representing F(s)
    %   t : scalar or vector of positive time values
    %   M : number of Talbot terms, default = 64
    %
    % Output:
    %   ilt : numerical inverse Laplace transform at t

    % Default number of terms
    if nargin < 3
        M = 64;
    end

    % Preserve the original shape of t
    original_size = size(t);

    % Convert t to a column vector
    t = t(:);

    % Check that all time values are positive
    if any(t <= 0)
        error('All time values must be positive.');
    end

    % Preallocate result
    ilt = zeros(length(t), 1);

    % Talbot contour angles
    k = 1:(M-1);
    theta = (pi/M) * k;
    cot_theta = cot(theta);

    % Talbot contour parameters
    delta = zeros(1, M);

    % Correct first contour point
    delta(1) = 2*M/5;

    delta(2:end) = ...
        (2*M/5) * theta .* (cot_theta + 1i);

    % Talbot weights
    gamma = zeros(1, M);
    gamma(1) = 0.5 * exp(delta(1));
    gamma(2:end) = ...
        (1 ...
        + 1i*theta.*(1 + cot_theta.^2) ...
        - 1i*cot_theta) ...
        .* exp(delta(2:end));
    % Evaluate the inverse transform
    for i = 1:length(t)
        s_vals = delta / t(i);
        f_vals = arrayfun(F, s_vals);
        ilt(i) = ...
            (0.4/t(i)) * sum(real(gamma .* f_vals));
    end
    % Restore original shape
    ilt = reshape(ilt, original_size);
end

[Torsten]

@dpb

The denominator can be evaluated without reference to sigma - thus it must be independent of sigma.

L^(-1) (F(s)/a) = 1/a * L^(-1)(F(s)), and this should be "ratio", I think, not L^(-1) (F(s))/L^(-1) (a) .

params = struct('s1',2, 'rho1',0,'s2',0, 'alpha',1, 'j',0.1,'mu1',1,'mu2',0.001);
c_vals = [1, 4, 6, 10]; % 4 specific curves to compare
for k = 1:length(c_vals)
  params.c = c_vals(k);
  U_func_s1(params)
end

ans = 0.0938

ans = 0.1234

ans = 0.1255

ans = 0.1240

function val = U_func_s1(p)
    % Copy your logic from the original calc_s1.m U_function here
    % Ensure it returns 'val'
    % Unpack1
    s1 = p.s1; alpha=p.alpha; 
    s2 = p.s2; c = p.c; j = p.j; rho1 = p.rho1; 
    mu2=p.mu2; mu1=p.mu1;

    l = sqrt(c*s1*(2+c)/(1+c));
    x0=-(1/2)*(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1-6*alpha*c*l^3*mu1-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2+3*alpha^2*c^2*l*s2-3*alpha^2*l^3*mu1*mu2-3*alpha^2*l^2*mu1*mu2-6*l^3*mu1*mu2-6*l^2*mu1*mu2+9*c^2-alpha^3*l^3*mu1*mu2-alpha^3*l^2*mu1*mu2-6*alpha*l^3*mu1*mu2-6*alpha*l^2*mu1*mu2+3*alpha^2*c^2+9*c^2*l-18*c*mu1+9*alpha*c^2+3*c^2*l^2+alpha^2*c^2*l^2-6*c*l^3*mu1-12*c*l^2*mu1+6*c*l^2*mu2+3*alpha*c^2*l^2+6*alpha^2*c*l*mu2*s2-9*alpha^2*c*l*mu1+6*alpha^2*c*l*mu2+6*alpha^2*c*mu2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-18*alpha*c*l*mu1+18*alpha*c*l*mu2-18*alpha*c*mu1+18*alpha*c*mu2+18*mu2*c+3*alpha^2*c^2*l+3*alpha^2*c^2*s2-9*alpha^2*c*mu1+6*alpha^2*c*mu2-18*c*l*mu1+18*c*l*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*mu1+9*alpha*c^2*l+(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+2*alpha^3*c*l^2*mu2*s2-alpha^3*l^3*mu1*mu2+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1+6*alpha^3*c*l*mu2*s2-alpha^3*l^2*mu1*mu2-alpha^2*c^2*l^2*s2+3*alpha^2*c*l^3*mu1-2*alpha^2*c*l^2*mu2*s2+3*alpha^2*l^3*mu1*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-alpha^2*c^2*l^2-3*alpha^2*c^2*l*s2+6*alpha^2*c*l^2*mu1-2*alpha^2*c*l^2*mu2-6*alpha^2*c*l*mu2*s2+3*alpha^2*l^2*mu1*mu2-6*alpha*c*l^3*mu1-6*alpha*l^3*mu1*mu2-3*alpha^3*c*mu1-3*alpha^2*c^2*l-3*alpha^2*c^2*s2+9*alpha^2*c*l*mu1-6*alpha^2*c*l*mu2-6*alpha^2*c*mu2*s2+3*alpha*c^2*l^2-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2-6*alpha*l^2*mu1*mu2+6*c*l^3*mu1+6*l^3*mu1*mu2-3*alpha^2*c^2+9*alpha^2*c*mu1-6*alpha^2*c*mu2+9*alpha*c^2*l-18*alpha*c*l*mu1+18*alpha*c*l*mu2-3*c^2*l^2+12*c*l^2*mu1-6*c*l^2*mu2+6*l^2*mu1*mu2+9*alpha*c^2-18*alpha*c*mu1+18*alpha*c*mu2-9*c^2*l+18*c*l*mu1-18*c*l*mu2-9*c^2+18*c*mu1-18*c*mu2)*exp(2*alpha)+2*alpha^2*c*l^2*mu2*s2+2*alpha^3*c*l^2*mu2*s2+6*alpha^3*c*l*mu2*s2+alpha^2*c^2*l^2*s2-3*alpha^2*c*l^3*mu1-6*alpha^2*c*l^2*mu1+2*alpha^2*c*l^2*mu2)/(l^2*((alpha^3*c^2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+2*alpha^3*l*mu1*mu2+alpha^3*c*mu1+2*alpha^3*mu1*mu2+3*alpha^2*c^2*l-alpha^2*c^2*s2-6*alpha^2*c*l*mu1+9*alpha^2*c*l*mu2-2*alpha^2*c*mu2*s2-6*alpha^2*l*mu1*mu2+6*alpha^2*l*mu2^2+2*alpha^2*c^2-3*alpha^2*c*mu1+7*alpha^2*c*mu2-6*alpha^2*mu1*mu2+6*alpha^2*mu2^2-9*alpha*c^2*l+12*alpha*c*l*mu1-27*alpha*c*l*mu2+12*alpha*l*mu1*mu2-18*alpha*l*mu2^2-6*alpha*c^2+6*alpha*c*mu1-21*alpha*c*mu2+12*alpha*mu1*mu2-18*alpha*mu2^2+9*c^2*l-12*c*l*mu1+27*c*l*mu2-12*l*mu1*mu2+18*l*mu2^2+6*c^2-6*c*mu1+21*c*mu2-12*mu1*mu2+18*mu2^2)*exp(2*alpha)-6*alpha^2*l*mu2^2+6*alpha^2*mu1*mu2+12*l*mu1*mu2-6*alpha^2*mu2^2-18*l*mu2^2+12*mu1*mu2-6*c^2+2*alpha^3*l*mu1*mu2+12*alpha*l*mu1*mu2-2*alpha^2*c^2-9*c^2*l+6*c*mu1-6*alpha*c^2-18*alpha*mu2^2+2*alpha^3*mu1*mu2-18*alpha*l*mu2^2+12*alpha*mu1*mu2+6*alpha^2*l*mu1*mu2+6*alpha^2*c*l*mu1-9*alpha^2*c*l*mu2+2*alpha^2*c*mu2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+12*alpha*c*l*mu1-27*alpha*c*l*mu2+6*alpha*c*mu1-21*alpha*c*mu2-21*mu2*c-18*mu2^2-3*alpha^2*c^2*l+alpha^2*c^2*s2+3*alpha^2*c*mu1-7*alpha^2*c*mu2+12*c*l*mu1-27*c*l*mu2+alpha^3*c^2*s2+alpha^3*c*mu1-9*alpha*c^2*l));
    val=(1/(2*(2+c)*pi*x0));
end

Answer 1

[dpb]

@Torsten may well have the best theoretical approach, but reverting to the empirical approach using 10X the end time gets reasonably close...however, the previous conclusion that the functional had eliminated the numerical issues for large times was in error, just that the small plot scale used disguised it. Trying to use larger time multiples begins to make the curves diverge to different end ratios owing the numeric issues.

sh1()

function sh1()
clc; close all;
    t_values = logspace(0, 3, 100);
    c_vals = [1, 4, 6, 10]; % 4 specific curves to compare
    params = struct('s1',2, 'rho1',0,'s2',0, 'alpha',1, 'j',0.1,'mu1',1,'mu2',0.001);
    figure; hold on;
    colors = ['r', 'g', 'b', 'm']; % 4 colors for the three curves

    % Steady-state velocity for this value of c
    tSS=10*t_values(end);                      % approximate large t for SS
    for k = 1:length(c_vals)
        params.c = c_vals(k);
        u_s1 = zeros(size(t_values));
        for i = 1:length(t_values)
          u_s1(i) = talbot_inversion(@(sigma) U_func_s1(sigma, params), t_values(i));
        end
        uSS=talbot_inversion(@(sigma) U_func_s1(sigma, params), tSS);
        % Calculate ratio
        ratio = u_s1/uSS;
        % Plot
        plot(t_values, ratio, 'Color', colors(k), 'LineWidth', 2, ...
            'DisplayName', sprintf('c=%.2f', c_vals(k)));
    end
    set(gca, 'XScale', 'log');
    xlabel('Time (t)'); ylabel('Ratio (U_{uns}/U_{std})');
    legend('Location', 'best'); grid on;
%    title('Effect of Micropolar Coupling on Dispersion Ratio');
end

% --- Rename your existing logic to avoid conflicts ---
function val = U_func_s1(sigma, p)
    % Copy your logic from the original calc_s1.m U_function here
    % Ensure it returns 'val'
    % Unpack1
    s1 = p.s1; alpha=p.alpha; 
    s2 = p.s2; c = p.c; j = p.j; rho1 = p.rho1; 
    mu2=p.mu2; mu1=p.mu1;


    % Define S (sum) and P (product)
    xi=sqrt(alpha^2+sigma);
    l = sqrt(c*s1*(2+c)/(1+c));

    % Calculate roots
    S0 = l^2 + (sigma * (1 + j * s1 * (1 + c))) / (1 + c);
    P0 = (sigma * s1 * (4 * c + j * sigma)) / (1 + c);  
    lambda1 = sqrt((S0 - sqrt(S0^2 - 4*P0)) / 2);
    lambda2 = sqrt((S0 + sqrt(S0^2 - 4*P0)) / 2);
   x1 = -(-(72 * lambda1 ^ 2 * lambda2 * mu1) - (72 * lambda1 * lambda2 ^ 2 * mu1) - (36 * lambda1 * mu1 * xi ^ 2) + (24 * lambda1 * mu2 * xi ^ 2) - (36 * lambda2 * mu1 * xi ^ 2) + (24 * lambda2 * mu2 * xi ^ 2) + (72 * c * lambda1 * lambda2 * xi) + (12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) - (72 * c * lambda2 * mu1) + (72 * c * lambda2 * mu2) + (72 * c * lambda1 * mu2) - (72 * c * lambda2 ^ 2 * mu1) + (72 * c * lambda2 ^ 2 * mu2) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (36 * c ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (72 * lambda2 * mu1) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (24 * lambda1 * lambda2 * mu1 * xi ^ 3) - (144 * lambda1 * lambda2 * mu1) - (72 * lambda1 ^ 2 * mu1) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (12 * c * lambda2 * mu1 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * lambda1 * mu1 * xi ^ 3) - (12 * lambda2 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2) + (72 * lambda2 ^ 2 * mu2) + (72 * lambda1 * mu2) + (72 * lambda2 * mu2) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) - (24 * c * lambda1 * lambda2 * mu1 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1) + (72 * c * lambda1 ^ 2 * mu2) + (144 * c * lambda1 * lambda2 * mu2) + (36 * c ^ 2 * lambda1 ^ 2 * xi) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2) + (12 * c ^ 2 * lambda1 * xi ^ 2) + (12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda2 * xi ^ 2) + (36 * c * lambda1 * xi) + (36 * c * lambda2 * xi) + (36 * c ^ 2 * lambda2) + (36 * c ^ 2 * lambda1) + (24 * c * lambda1 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 3) + (36 * c ^ 2 * lambda1 ^ 2) + (36 * c ^ 2 * lambda2 ^ 2) + (72 * c ^ 2 * lambda1 * lambda2) + (36 * c * lambda2 ^ 2) + (36 * c * lambda1) + (36 * c * lambda2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (6 * c * lambda1 * s2 * xi ^ 3) + (6 * c * lambda2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 2) + (72 * c ^ 2 * lambda1 * lambda2 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2) - (36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) - (72 * lambda2 ^ 2 * mu1 * xi) + (72 * lambda2 ^ 2 * mu2 * xi) - (12 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * c * lambda2 * mu1 * xi) + (72 * c * lambda2 * mu2 * xi) - (144 * c * lambda1 * lambda2 * mu1) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2) - (36 * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * lambda2 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) - (144 * lambda1 * lambda2 * mu1 * xi) + (144 * lambda1 * lambda2 * mu2 * xi) + (72 * lambda1 * lambda2 ^ 2 * mu2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * lambda1 * lambda2 ^ 2 * mu1 * xi) - (72 * lambda1 ^ 2 * lambda2 * mu1 * xi) + (36 * c * lambda1 ^ 2 * lambda2) + (36 * c * lambda1 * lambda2 ^ 2) + (72 * c * lambda1 * lambda2) - (36 * c * lambda2 * mu1 * xi ^ 2) + (24 * c * lambda2 * mu2 * xi ^ 2) + (24 * c * lambda1 * mu2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2) - (72 * c * lambda1 * lambda2 ^ 2 * mu1) - (72 * c * lambda1 ^ 2 * lambda2 * mu1) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) - (72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi) - (72 * lambda1 * mu1 * xi) + (72 * lambda1 * mu2 * xi) - (72 * lambda2 * mu1 * xi) + (72 * lambda2 * mu2 * xi) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * lambda1 ^ 2 * xi ^ 3 * mu1) - (36 * lambda1 ^ 2 * xi ^ 2 * mu1) - (72 * lambda1 ^ 2 * mu1 * xi) + (24 * lambda1 ^ 2 * mu2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2) - (36 * c * lambda1 * mu1 * xi ^ 2) + (48 * c * lambda1 * lambda2 * mu2 * xi ^ 2) - (144 * c * lambda1 * lambda2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (36 * c ^ 2 * lambda1 * xi) + (36 * c ^ 2 * lambda2 * xi) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 2) - (12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * lambda1 * mu1) - (72 * lambda2 ^ 2 * mu1) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (36 * c * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * c * lambda2 ^ 2 * mu2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * lambda2 * xi) + (36 * c * lambda1 * lambda2 ^ 2 * xi) - (72 * c * lambda2 ^ 2 * mu1 * xi) + (72 * c * lambda2 ^ 2 * mu2 * xi) + (6 * c * lambda1 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 * mu2 * s2 * xi ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) - (12 * c * lambda2 ^ 2 * mu1 * xi ^ 3) + (12 * c ^ 2 * lambda2 * xi ^ 2) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 3) - (6 * c * lambda1 * sigma * xi) - (72 * c * lambda1 * mu1) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2) - (72 * c * lambda1 * mu1 * xi) + (72 * c * lambda1 * mu2 * xi) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) + (72 * c * lambda1 ^ 2 * mu2 * xi) + (36 * c * lambda1 ^ 2) + (24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2) + (24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) - (72 * lambda1 * lambda2 * mu1 * xi ^ 2) + (48 * lambda1 * lambda2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) - (12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (24 * c * lambda1 * lambda2 * xi ^ 2) + (6 * c * lambda1 * s2 * xi ^ 2) + (6 * c * lambda2 * s2 * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi) - (12 * c * lambda1 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (12 * c * lambda2 ^ 2 * xi ^ 2) + (36 * c * lambda2 ^ 2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi) - (72 * c * lambda1 * lambda2 * mu1 * xi ^ 2) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * mu1 * xi ^ 3) + (12 * c * lambda1 * xi ^ 2) - (36 * c * lambda1 ^ 2 * mu1 * xi ^ 2) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda1 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 * mu2 * s2 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1 * xi) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi) + (144 * c * lambda1 * lambda2 * mu2 * xi) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2) + (72 * lambda1 * lambda2 ^ 2 * mu2) + (144 * lambda1 * lambda2 * mu2) + (12 * c * lambda1 ^ 2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3 + 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 + 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3 - 12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 + 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2 - 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda2 * s2 * xi ^ 3 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 12 * c * lambda1 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * s2 * xi ^ 3 + 36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 - 24 * c * lambda1 * lambda2 * mu1 * xi ^ 3 - 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 + 12 * c * lambda1 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 12 * c * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2 + 36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi - 24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda2 * s2 * xi ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi - 72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi + 72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 - 72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi - 12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * c * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * c * lambda1 * lambda2 * s2 * xi ^ 2 - 12 * c * lambda1 * mu1 * xi ^ 3 - 6 * c * lambda1 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * s2 * sigma * xi ^ 2 + 6 * c * lambda1 * s2 * xi ^ 3 + 36 * c * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 - 12 * c * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 + 6 * c * lambda2 * s2 * xi ^ 3 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi + 36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * xi ^ 3 * mu1 + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 + 36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 - 24 * lambda1 * lambda2 * mu1 * xi ^ 3 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 - 12 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 36 * c ^ 2 * lambda1 ^ 2 * lambda2 + 36 * c ^ 2 * lambda1 ^ 2 * xi - 36 * c ^ 2 * lambda1 * lambda2 ^ 2 + 72 * c ^ 2 * lambda1 * lambda2 * xi - 12 * c ^ 2 * lambda1 * xi ^ 2 + 36 * c ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda2 * xi ^ 2 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 + 72 * c * lambda1 ^ 2 * lambda2 * mu1 - 72 * c * lambda1 ^ 2 * lambda2 * mu2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 36 * c * lambda1 ^ 2 * lambda2 * xi - 72 * c * lambda1 ^ 2 * mu1 * xi + 72 * c * lambda1 ^ 2 * mu2 * xi + 6 * c * lambda1 ^ 2 * sigma * xi - 12 * c * lambda1 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 ^ 2 * mu1 - 72 * c * lambda1 * lambda2 ^ 2 * mu2 - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 36 * c * lambda1 * lambda2 ^ 2 * xi - 144 * c * lambda1 * lambda2 * mu1 * xi + 144 * c * lambda1 * lambda2 * mu2 * xi - 24 * c * lambda1 * lambda2 * xi ^ 2 + 36 * c * lambda1 * mu1 * xi ^ 2 - 24 * c * lambda1 * mu2 * xi ^ 2 - 6 * c * lambda1 * s2 * xi ^ 2 + 2 * c * lambda1 * sigma * xi ^ 2 - 72 * c * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda2 ^ 2 * sigma * xi - 12 * c * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda2 * s2 * xi ^ 2 + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 - 72 * lambda1 ^ 2 * lambda2 * mu1 * xi + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma + 72 * lambda1 ^ 2 * lambda2 * mu2 * xi + 36 * lambda1 ^ 2 * xi ^ 2 * mu1 - 12 * lambda1 ^ 2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * mu2 * xi ^ 2 - 72 * lambda1 * lambda2 ^ 2 * mu1 * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda1 * lambda2 ^ 2 * mu2 * xi + 24 * lambda1 * lambda2 * mu1 * sigma * xi + 72 * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 * mu1 * sigma * xi ^ 2 - 12 * lambda1 * mu1 * xi ^ 3 + 12 * lambda1 * mu2 * sigma * xi ^ 2 + 36 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda2 * mu1 * sigma * xi ^ 2 - 12 * lambda2 * mu1 * xi ^ 3 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 36 * c ^ 2 * lambda1 ^ 2 - 72 * c ^ 2 * lambda1 * lambda2 + 36 * c ^ 2 * lambda1 * xi - 36 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda2 * xi - 36 * c * lambda1 ^ 2 * lambda2 + 72 * c * lambda1 ^ 2 * mu1 - 72 * c * lambda1 ^ 2 * mu2 - 6 * c * lambda1 ^ 2 * sigma + 36 * c * lambda1 ^ 2 * xi - 36 * c * lambda1 * lambda2 ^ 2 + 144 * c * lambda1 * lambda2 * mu1 - 144 * c * lambda1 * lambda2 * mu2 + 72 * c * lambda1 * lambda2 * xi - 72 * c * lambda1 * mu1 * xi + 72 * c * lambda1 * mu2 * xi - 6 * c * lambda1 * sigma * xi - 12 * c * lambda1 * xi ^ 2 + 72 * c * lambda2 ^ 2 * mu1 - 72 * c * lambda2 ^ 2 * mu2 - 6 * c * lambda2 ^ 2 * sigma + 36 * c * lambda2 ^ 2 * xi - 72 * c * lambda2 * mu1 * xi + 72 * c * lambda2 * mu2 * xi - 6 * c * lambda2 * sigma * xi - 12 * c * lambda2 * xi ^ 2 + 72 * lambda1 ^ 2 * lambda2 * mu1 - 72 * lambda1 ^ 2 * lambda2 * mu2 - 72 * lambda1 ^ 2 * mu1 * xi + 12 * lambda1 ^ 2 * mu2 * sigma + 72 * lambda1 ^ 2 * mu2 * xi + 72 * lambda1 * lambda2 ^ 2 * mu1 - 72 * lambda1 * lambda2 ^ 2 * mu2 - 24 * lambda1 * lambda2 * mu1 * sigma - 144 * lambda1 * lambda2 * mu1 * xi + 48 * lambda1 * lambda2 * mu2 * sigma + 144 * lambda1 * lambda2 * mu2 * xi + 24 * lambda1 * mu1 * sigma * xi + 36 * lambda1 * mu1 * xi ^ 2 - 36 * lambda1 * mu2 * sigma * xi - 24 * lambda1 * mu2 * xi ^ 2 - 72 * lambda2 ^ 2 * mu1 * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda2 ^ 2 * mu2 * xi + 24 * lambda2 * mu1 * sigma * xi + 36 * lambda2 * mu1 * xi ^ 2 - 36 * lambda2 * mu2 * sigma * xi - 24 * lambda2 * mu2 * xi ^ 2 - 36 * c ^ 2 * lambda1 - 36 * c ^ 2 * lambda2 - 36 * c * lambda1 ^ 2 - 72 * c * lambda1 * lambda2 + 72 * c * lambda1 * mu1 - 72 * c * lambda1 * mu2 + 6 * c * lambda1 * sigma + 36 * c * lambda1 * xi - 36 * c * lambda2 ^ 2 + 72 * c * lambda2 * mu1 - 72 * c * lambda2 * mu2 + 6 * c * lambda2 * sigma + 36 * c * lambda2 * xi + 72 * lambda1 ^ 2 * mu1 - 72 * lambda1 ^ 2 * mu2 + 144 * lambda1 * lambda2 * mu1 - 144 * lambda1 * lambda2 * mu2 - 24 * lambda1 * mu1 * sigma - 72 * lambda1 * mu1 * xi + 36 * lambda1 * mu2 * sigma + 72 * lambda1 * mu2 * xi + 72 * lambda2 ^ 2 * mu1 - 72 * lambda2 ^ 2 * mu2 - 24 * lambda2 * mu1 * sigma - 72 * lambda2 * mu1 * xi + 36 * lambda2 * mu2 * sigma + 72 * lambda2 * mu2 * xi - 36 * c * lambda1 - 36 * c * lambda2 + 72 * lambda1 * mu1 - 72 * lambda1 * mu2 + 72 * lambda2 * mu1 - 72 * lambda2 * mu2) * exp((2 * xi))) / (-(12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi + 2 * c * lambda1 * s2 * sigma * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 6 * c * lambda1 ^ 2 * sigma * xi - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 2 * c * lambda1 * sigma * xi ^ 2 + 6 * c * lambda2 ^ 2 * sigma * xi + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma - 12 * lambda1 ^ 2 * mu2 * sigma * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda1 * lambda2 * mu1 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 12 * lambda1 * mu1 * sigma * xi ^ 2 + 12 * lambda1 * mu2 * sigma * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda2 * mu1 * sigma * xi ^ 2 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 6 * c * lambda1 ^ 2 * sigma - 6 * c * lambda1 * sigma * xi - 6 * c * lambda2 ^ 2 * sigma - 6 * c * lambda2 * sigma * xi + 12 * lambda1 ^ 2 * mu2 * sigma - 24 * lambda1 * lambda2 * mu1 * sigma + 48 * lambda1 * lambda2 * mu2 * sigma + 24 * lambda1 * mu1 * sigma * xi - 36 * lambda1 * mu2 * sigma * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda2 * mu1 * sigma * xi - 36 * lambda2 * mu2 * sigma * xi + 6 * c * lambda1 * sigma + 6 * c * lambda2 * sigma - 24 * lambda1 * mu1 * sigma + 36 * lambda1 * mu2 * sigma - 24 * lambda2 * mu1 * sigma + 36 * lambda2 * mu2 * sigma) * exp((2 * xi)) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) - (6 * c * lambda1 * sigma * xi) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi)) / 0.2e1;
   x0=-(1/2)*(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1-6*alpha*c*l^3*mu1-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2+3*alpha^2*c^2*l*s2-3*alpha^2*l^3*mu1*mu2-3*alpha^2*l^2*mu1*mu2-6*l^3*mu1*mu2-6*l^2*mu1*mu2+9*c^2-alpha^3*l^3*mu1*mu2-alpha^3*l^2*mu1*mu2-6*alpha*l^3*mu1*mu2-6*alpha*l^2*mu1*mu2+3*alpha^2*c^2+9*c^2*l-18*c*mu1+9*alpha*c^2+3*c^2*l^2+alpha^2*c^2*l^2-6*c*l^3*mu1-12*c*l^2*mu1+6*c*l^2*mu2+3*alpha*c^2*l^2+6*alpha^2*c*l*mu2*s2-9*alpha^2*c*l*mu1+6*alpha^2*c*l*mu2+6*alpha^2*c*mu2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-18*alpha*c*l*mu1+18*alpha*c*l*mu2-18*alpha*c*mu1+18*alpha*c*mu2+18*mu2*c+3*alpha^2*c^2*l+3*alpha^2*c^2*s2-9*alpha^2*c*mu1+6*alpha^2*c*mu2-18*c*l*mu1+18*c*l*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*mu1+9*alpha*c^2*l+(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+2*alpha^3*c*l^2*mu2*s2-alpha^3*l^3*mu1*mu2+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1+6*alpha^3*c*l*mu2*s2-alpha^3*l^2*mu1*mu2-alpha^2*c^2*l^2*s2+3*alpha^2*c*l^3*mu1-2*alpha^2*c*l^2*mu2*s2+3*alpha^2*l^3*mu1*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-alpha^2*c^2*l^2-3*alpha^2*c^2*l*s2+6*alpha^2*c*l^2*mu1-2*alpha^2*c*l^2*mu2-6*alpha^2*c*l*mu2*s2+3*alpha^2*l^2*mu1*mu2-6*alpha*c*l^3*mu1-6*alpha*l^3*mu1*mu2-3*alpha^3*c*mu1-3*alpha^2*c^2*l-3*alpha^2*c^2*s2+9*alpha^2*c*l*mu1-6*alpha^2*c*l*mu2-6*alpha^2*c*mu2*s2+3*alpha*c^2*l^2-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2-6*alpha*l^2*mu1*mu2+6*c*l^3*mu1+6*l^3*mu1*mu2-3*alpha^2*c^2+9*alpha^2*c*mu1-6*alpha^2*c*mu2+9*alpha*c^2*l-18*alpha*c*l*mu1+18*alpha*c*l*mu2-3*c^2*l^2+12*c*l^2*mu1-6*c*l^2*mu2+6*l^2*mu1*mu2+9*alpha*c^2-18*alpha*c*mu1+18*alpha*c*mu2-9*c^2*l+18*c*l*mu1-18*c*l*mu2-9*c^2+18*c*mu1-18*c*mu2)*exp(2*alpha)+2*alpha^2*c*l^2*mu2*s2+2*alpha^3*c*l^2*mu2*s2+6*alpha^3*c*l*mu2*s2+alpha^2*c^2*l^2*s2-3*alpha^2*c*l^3*mu1-6*alpha^2*c*l^2*mu1+2*alpha^2*c*l^2*mu2)/(l^2*((alpha^3*c^2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+2*alpha^3*l*mu1*mu2+alpha^3*c*mu1+2*alpha^3*mu1*mu2+3*alpha^2*c^2*l-alpha^2*c^2*s2-6*alpha^2*c*l*mu1+9*alpha^2*c*l*mu2-2*alpha^2*c*mu2*s2-6*alpha^2*l*mu1*mu2+6*alpha^2*l*mu2^2+2*alpha^2*c^2-3*alpha^2*c*mu1+7*alpha^2*c*mu2-6*alpha^2*mu1*mu2+6*alpha^2*mu2^2-9*alpha*c^2*l+12*alpha*c*l*mu1-27*alpha*c*l*mu2+12*alpha*l*mu1*mu2-18*alpha*l*mu2^2-6*alpha*c^2+6*alpha*c*mu1-21*alpha*c*mu2+12*alpha*mu1*mu2-18*alpha*mu2^2+9*c^2*l-12*c*l*mu1+27*c*l*mu2-12*l*mu1*mu2+18*l*mu2^2+6*c^2-6*c*mu1+21*c*mu2-12*mu1*mu2+18*mu2^2)*exp(2*alpha)-6*alpha^2*l*mu2^2+6*alpha^2*mu1*mu2+12*l*mu1*mu2-6*alpha^2*mu2^2-18*l*mu2^2+12*mu1*mu2-6*c^2+2*alpha^3*l*mu1*mu2+12*alpha*l*mu1*mu2-2*alpha^2*c^2-9*c^2*l+6*c*mu1-6*alpha*c^2-18*alpha*mu2^2+2*alpha^3*mu1*mu2-18*alpha*l*mu2^2+12*alpha*mu1*mu2+6*alpha^2*l*mu1*mu2+6*alpha^2*c*l*mu1-9*alpha^2*c*l*mu2+2*alpha^2*c*mu2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+12*alpha*c*l*mu1-27*alpha*c*l*mu2+6*alpha*c*mu1-21*alpha*c*mu2-21*mu2*c-18*mu2^2-3*alpha^2*c^2*l+alpha^2*c^2*s2+3*alpha^2*c*mu1-7*alpha^2*c*mu2+12*c*l*mu1-27*c*l*mu2+alpha^3*c^2*s2+alpha^3*c*mu1-9*alpha*c^2*l));
   val =(3/(4*pi*sigma^2*(rho1-1 -3*x1)))/(1/(2*(2+c)*pi*x0));
   %val =(3/(4*pi*sigma^2*(rho1-1 -3*x1)));
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function ilt = talbot_inversion(F, t, M)
    % TALBOT_INVERSION
    % Numerical inverse Laplace transform using the fixed Talbot method
    %
    % ilt = talbot_inversion(F, t, M)
    %
    % Inputs:
    %   F : function handle representing F(s)
    %   t : scalar or vector of positive time values
    %   M : number of Talbot terms, default = 64
    %
    % Output:
    %   ilt : numerical inverse Laplace transform at t

    % Default number of terms
    if nargin < 3
        M = 64;
    end

    % Preserve the original shape of t
    original_size = size(t);

    % Convert t to a column vector
    t = t(:);

    % Check that all time values are positive
    if any(t <= 0)
        error('All time values must be positive.');
    end

    % Preallocate result
    ilt = zeros(length(t), 1);

    % Talbot contour angles
    k = 1:(M-1);
    theta = (pi/M) * k;
    cot_theta = cot(theta);

    % Talbot contour parameters
    delta = zeros(1, M);

    % Correct first contour point
    delta(1) = 2*M/5;

    delta(2:end) = ...
        (2*M/5) * theta .* (cot_theta + 1i);

    % Talbot weights
    gamma = zeros(1, M);
    gamma(1) = 0.5 * exp(delta(1));
    gamma(2:end) = ...
        (1 ...
        + 1i*theta.*(1 + cot_theta.^2) ...
        - 1i*cot_theta) ...
        .* exp(delta(2:end));
    % Evaluate the inverse transform
    for i = 1:length(t)
        s_vals = delta / t(i);
        f_vals = arrayfun(F, s_vals);
        ilt(i) = ...
            (0.4/t(i)) * sum(real(gamma .* f_vals));
    end
    % Restore original shape
    ilt = reshape(ilt, original_size);
end

[dpb]

There is no zero on a log scale, and you started at 1 with the logspace() parameters...the empirical doesn't do too badly over the ranges but certainly the analytic is better...but, you can't take the calculation past this point...

sh1()

Warning: Graphics acceleration hardware is unavailable. Graphics quality and performance might be diminished. See MATLAB System Requirements.

function sh1()
clc; close all;
    t_values = logspace(-4, 6, 100);
    c_vals = [1, 4, 6, 10]; % 4 specific curves to compare
    params = struct('s1',2, 'rho1',0,'s2',0, 'alpha',1, 'j',0.1,'mu1',1,'mu2',0.001);
    figure; hold on;
    colors = ['r', 'g', 'b', 'm']; % 4 colors for the three curves

    % Steady-state velocity for this value of c
    %tSS=t_values(end);                      % approximate large t for SS
    tSS=10E4;
    for k = 1:length(c_vals)
        params.c = c_vals(k);
        u_s1 = zeros(size(t_values));
        for i = 1:length(t_values)
          u_s1(i) = talbot_inversion(@(sigma) U_func_s1(sigma, params), t_values(i));
        end
        uSS=talbot_inversion(@(sigma) U_func_s1(sigma, params), tSS);
        % Calculate ratio
        ratio = u_s1/uSS;
        % Plot
        plot(t_values, ratio, 'Color', colors(k), 'LineWidth', 2, ...
            'DisplayName', sprintf('c=%.2f', c_vals(k)));
    end
    set(gca, 'XScale', 'log');
    ylim([0 1])
    xlabel('Time (t)'); ylabel('Ratio (U_{uns}/U_{std})');
    legend('Location', 'best'); grid on;
%    title('Effect of Micropolar Coupling on Dispersion Ratio');
end

% --- Rename your existing logic to avoid conflicts ---
function val = U_func_s1(sigma, p)
    % Copy your logic from the original calc_s1.m U_function here
    % Ensure it returns 'val'
    % Unpack1
    s1 = p.s1; alpha=p.alpha; 
    s2 = p.s2; c = p.c; j = p.j; rho1 = p.rho1; 
    mu2=p.mu2; mu1=p.mu1;


    % Define S (sum) and P (product)
    xi=sqrt(alpha^2+sigma);
    l = sqrt(c*s1*(2+c)/(1+c));

    % Calculate roots
    S0 = l^2 + (sigma * (1 + j * s1 * (1 + c))) / (1 + c);
    P0 = (sigma * s1 * (4 * c + j * sigma)) / (1 + c);  
    lambda1 = sqrt((S0 - sqrt(S0^2 - 4*P0)) / 2);
    lambda2 = sqrt((S0 + sqrt(S0^2 - 4*P0)) / 2);
   x1 = -(-(72 * lambda1 ^ 2 * lambda2 * mu1) - (72 * lambda1 * lambda2 ^ 2 * mu1) - (36 * lambda1 * mu1 * xi ^ 2) + (24 * lambda1 * mu2 * xi ^ 2) - (36 * lambda2 * mu1 * xi ^ 2) + (24 * lambda2 * mu2 * xi ^ 2) + (72 * c * lambda1 * lambda2 * xi) + (12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) - (72 * c * lambda2 * mu1) + (72 * c * lambda2 * mu2) + (72 * c * lambda1 * mu2) - (72 * c * lambda2 ^ 2 * mu1) + (72 * c * lambda2 ^ 2 * mu2) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (36 * c ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (72 * lambda2 * mu1) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (24 * lambda1 * lambda2 * mu1 * xi ^ 3) - (144 * lambda1 * lambda2 * mu1) - (72 * lambda1 ^ 2 * mu1) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (12 * c * lambda2 * mu1 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * lambda1 * mu1 * xi ^ 3) - (12 * lambda2 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2) + (72 * lambda2 ^ 2 * mu2) + (72 * lambda1 * mu2) + (72 * lambda2 * mu2) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) - (24 * c * lambda1 * lambda2 * mu1 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1) + (72 * c * lambda1 ^ 2 * mu2) + (144 * c * lambda1 * lambda2 * mu2) + (36 * c ^ 2 * lambda1 ^ 2 * xi) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2) + (12 * c ^ 2 * lambda1 * xi ^ 2) + (12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda2 * xi ^ 2) + (36 * c * lambda1 * xi) + (36 * c * lambda2 * xi) + (36 * c ^ 2 * lambda2) + (36 * c ^ 2 * lambda1) + (24 * c * lambda1 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 3) + (36 * c ^ 2 * lambda1 ^ 2) + (36 * c ^ 2 * lambda2 ^ 2) + (72 * c ^ 2 * lambda1 * lambda2) + (36 * c * lambda2 ^ 2) + (36 * c * lambda1) + (36 * c * lambda2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (6 * c * lambda1 * s2 * xi ^ 3) + (6 * c * lambda2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 2) + (72 * c ^ 2 * lambda1 * lambda2 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2) - (36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) - (72 * lambda2 ^ 2 * mu1 * xi) + (72 * lambda2 ^ 2 * mu2 * xi) - (12 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * c * lambda2 * mu1 * xi) + (72 * c * lambda2 * mu2 * xi) - (144 * c * lambda1 * lambda2 * mu1) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2) - (36 * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * lambda2 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) - (144 * lambda1 * lambda2 * mu1 * xi) + (144 * lambda1 * lambda2 * mu2 * xi) + (72 * lambda1 * lambda2 ^ 2 * mu2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * lambda1 * lambda2 ^ 2 * mu1 * xi) - (72 * lambda1 ^ 2 * lambda2 * mu1 * xi) + (36 * c * lambda1 ^ 2 * lambda2) + (36 * c * lambda1 * lambda2 ^ 2) + (72 * c * lambda1 * lambda2) - (36 * c * lambda2 * mu1 * xi ^ 2) + (24 * c * lambda2 * mu2 * xi ^ 2) + (24 * c * lambda1 * mu2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2) - (72 * c * lambda1 * lambda2 ^ 2 * mu1) - (72 * c * lambda1 ^ 2 * lambda2 * mu1) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) - (72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi) - (72 * lambda1 * mu1 * xi) + (72 * lambda1 * mu2 * xi) - (72 * lambda2 * mu1 * xi) + (72 * lambda2 * mu2 * xi) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * lambda1 ^ 2 * xi ^ 3 * mu1) - (36 * lambda1 ^ 2 * xi ^ 2 * mu1) - (72 * lambda1 ^ 2 * mu1 * xi) + (24 * lambda1 ^ 2 * mu2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2) - (36 * c * lambda1 * mu1 * xi ^ 2) + (48 * c * lambda1 * lambda2 * mu2 * xi ^ 2) - (144 * c * lambda1 * lambda2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (36 * c ^ 2 * lambda1 * xi) + (36 * c ^ 2 * lambda2 * xi) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 2) - (12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * lambda1 * mu1) - (72 * lambda2 ^ 2 * mu1) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (36 * c * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * c * lambda2 ^ 2 * mu2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * lambda2 * xi) + (36 * c * lambda1 * lambda2 ^ 2 * xi) - (72 * c * lambda2 ^ 2 * mu1 * xi) + (72 * c * lambda2 ^ 2 * mu2 * xi) + (6 * c * lambda1 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 * mu2 * s2 * xi ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) - (12 * c * lambda2 ^ 2 * mu1 * xi ^ 3) + (12 * c ^ 2 * lambda2 * xi ^ 2) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 3) - (6 * c * lambda1 * sigma * xi) - (72 * c * lambda1 * mu1) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2) - (72 * c * lambda1 * mu1 * xi) + (72 * c * lambda1 * mu2 * xi) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) + (72 * c * lambda1 ^ 2 * mu2 * xi) + (36 * c * lambda1 ^ 2) + (24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2) + (24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) - (72 * lambda1 * lambda2 * mu1 * xi ^ 2) + (48 * lambda1 * lambda2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) - (12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (24 * c * lambda1 * lambda2 * xi ^ 2) + (6 * c * lambda1 * s2 * xi ^ 2) + (6 * c * lambda2 * s2 * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi) - (12 * c * lambda1 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (12 * c * lambda2 ^ 2 * xi ^ 2) + (36 * c * lambda2 ^ 2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi) - (72 * c * lambda1 * lambda2 * mu1 * xi ^ 2) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * mu1 * xi ^ 3) + (12 * c * lambda1 * xi ^ 2) - (36 * c * lambda1 ^ 2 * mu1 * xi ^ 2) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda1 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 * mu2 * s2 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1 * xi) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi) + (144 * c * lambda1 * lambda2 * mu2 * xi) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2) + (72 * lambda1 * lambda2 ^ 2 * mu2) + (144 * lambda1 * lambda2 * mu2) + (12 * c * lambda1 ^ 2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3 + 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 + 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3 - 12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 + 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2 - 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda2 * s2 * xi ^ 3 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 12 * c * lambda1 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * s2 * xi ^ 3 + 36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 - 24 * c * lambda1 * lambda2 * mu1 * xi ^ 3 - 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 + 12 * c * lambda1 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 12 * c * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2 + 36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi - 24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda2 * s2 * xi ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi - 72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi + 72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 - 72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi - 12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * c * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * c * lambda1 * lambda2 * s2 * xi ^ 2 - 12 * c * lambda1 * mu1 * xi ^ 3 - 6 * c * lambda1 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * s2 * sigma * xi ^ 2 + 6 * c * lambda1 * s2 * xi ^ 3 + 36 * c * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 - 12 * c * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 + 6 * c * lambda2 * s2 * xi ^ 3 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi + 36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * xi ^ 3 * mu1 + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 + 36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 - 24 * lambda1 * lambda2 * mu1 * xi ^ 3 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 - 12 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 36 * c ^ 2 * lambda1 ^ 2 * lambda2 + 36 * c ^ 2 * lambda1 ^ 2 * xi - 36 * c ^ 2 * lambda1 * lambda2 ^ 2 + 72 * c ^ 2 * lambda1 * lambda2 * xi - 12 * c ^ 2 * lambda1 * xi ^ 2 + 36 * c ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda2 * xi ^ 2 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 + 72 * c * lambda1 ^ 2 * lambda2 * mu1 - 72 * c * lambda1 ^ 2 * lambda2 * mu2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 36 * c * lambda1 ^ 2 * lambda2 * xi - 72 * c * lambda1 ^ 2 * mu1 * xi + 72 * c * lambda1 ^ 2 * mu2 * xi + 6 * c * lambda1 ^ 2 * sigma * xi - 12 * c * lambda1 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 ^ 2 * mu1 - 72 * c * lambda1 * lambda2 ^ 2 * mu2 - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 36 * c * lambda1 * lambda2 ^ 2 * xi - 144 * c * lambda1 * lambda2 * mu1 * xi + 144 * c * lambda1 * lambda2 * mu2 * xi - 24 * c * lambda1 * lambda2 * xi ^ 2 + 36 * c * lambda1 * mu1 * xi ^ 2 - 24 * c * lambda1 * mu2 * xi ^ 2 - 6 * c * lambda1 * s2 * xi ^ 2 + 2 * c * lambda1 * sigma * xi ^ 2 - 72 * c * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda2 ^ 2 * sigma * xi - 12 * c * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda2 * s2 * xi ^ 2 + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 - 72 * lambda1 ^ 2 * lambda2 * mu1 * xi + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma + 72 * lambda1 ^ 2 * lambda2 * mu2 * xi + 36 * lambda1 ^ 2 * xi ^ 2 * mu1 - 12 * lambda1 ^ 2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * mu2 * xi ^ 2 - 72 * lambda1 * lambda2 ^ 2 * mu1 * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda1 * lambda2 ^ 2 * mu2 * xi + 24 * lambda1 * lambda2 * mu1 * sigma * xi + 72 * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 * mu1 * sigma * xi ^ 2 - 12 * lambda1 * mu1 * xi ^ 3 + 12 * lambda1 * mu2 * sigma * xi ^ 2 + 36 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda2 * mu1 * sigma * xi ^ 2 - 12 * lambda2 * mu1 * xi ^ 3 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 36 * c ^ 2 * lambda1 ^ 2 - 72 * c ^ 2 * lambda1 * lambda2 + 36 * c ^ 2 * lambda1 * xi - 36 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda2 * xi - 36 * c * lambda1 ^ 2 * lambda2 + 72 * c * lambda1 ^ 2 * mu1 - 72 * c * lambda1 ^ 2 * mu2 - 6 * c * lambda1 ^ 2 * sigma + 36 * c * lambda1 ^ 2 * xi - 36 * c * lambda1 * lambda2 ^ 2 + 144 * c * lambda1 * lambda2 * mu1 - 144 * c * lambda1 * lambda2 * mu2 + 72 * c * lambda1 * lambda2 * xi - 72 * c * lambda1 * mu1 * xi + 72 * c * lambda1 * mu2 * xi - 6 * c * lambda1 * sigma * xi - 12 * c * lambda1 * xi ^ 2 + 72 * c * lambda2 ^ 2 * mu1 - 72 * c * lambda2 ^ 2 * mu2 - 6 * c * lambda2 ^ 2 * sigma + 36 * c * lambda2 ^ 2 * xi - 72 * c * lambda2 * mu1 * xi + 72 * c * lambda2 * mu2 * xi - 6 * c * lambda2 * sigma * xi - 12 * c * lambda2 * xi ^ 2 + 72 * lambda1 ^ 2 * lambda2 * mu1 - 72 * lambda1 ^ 2 * lambda2 * mu2 - 72 * lambda1 ^ 2 * mu1 * xi + 12 * lambda1 ^ 2 * mu2 * sigma + 72 * lambda1 ^ 2 * mu2 * xi + 72 * lambda1 * lambda2 ^ 2 * mu1 - 72 * lambda1 * lambda2 ^ 2 * mu2 - 24 * lambda1 * lambda2 * mu1 * sigma - 144 * lambda1 * lambda2 * mu1 * xi + 48 * lambda1 * lambda2 * mu2 * sigma + 144 * lambda1 * lambda2 * mu2 * xi + 24 * lambda1 * mu1 * sigma * xi + 36 * lambda1 * mu1 * xi ^ 2 - 36 * lambda1 * mu2 * sigma * xi - 24 * lambda1 * mu2 * xi ^ 2 - 72 * lambda2 ^ 2 * mu1 * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda2 ^ 2 * mu2 * xi + 24 * lambda2 * mu1 * sigma * xi + 36 * lambda2 * mu1 * xi ^ 2 - 36 * lambda2 * mu2 * sigma * xi - 24 * lambda2 * mu2 * xi ^ 2 - 36 * c ^ 2 * lambda1 - 36 * c ^ 2 * lambda2 - 36 * c * lambda1 ^ 2 - 72 * c * lambda1 * lambda2 + 72 * c * lambda1 * mu1 - 72 * c * lambda1 * mu2 + 6 * c * lambda1 * sigma + 36 * c * lambda1 * xi - 36 * c * lambda2 ^ 2 + 72 * c * lambda2 * mu1 - 72 * c * lambda2 * mu2 + 6 * c * lambda2 * sigma + 36 * c * lambda2 * xi + 72 * lambda1 ^ 2 * mu1 - 72 * lambda1 ^ 2 * mu2 + 144 * lambda1 * lambda2 * mu1 - 144 * lambda1 * lambda2 * mu2 - 24 * lambda1 * mu1 * sigma - 72 * lambda1 * mu1 * xi + 36 * lambda1 * mu2 * sigma + 72 * lambda1 * mu2 * xi + 72 * lambda2 ^ 2 * mu1 - 72 * lambda2 ^ 2 * mu2 - 24 * lambda2 * mu1 * sigma - 72 * lambda2 * mu1 * xi + 36 * lambda2 * mu2 * sigma + 72 * lambda2 * mu2 * xi - 36 * c * lambda1 - 36 * c * lambda2 + 72 * lambda1 * mu1 - 72 * lambda1 * mu2 + 72 * lambda2 * mu1 - 72 * lambda2 * mu2) * exp((2 * xi))) / (-(12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi + 2 * c * lambda1 * s2 * sigma * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 6 * c * lambda1 ^ 2 * sigma * xi - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 2 * c * lambda1 * sigma * xi ^ 2 + 6 * c * lambda2 ^ 2 * sigma * xi + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma - 12 * lambda1 ^ 2 * mu2 * sigma * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda1 * lambda2 * mu1 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 12 * lambda1 * mu1 * sigma * xi ^ 2 + 12 * lambda1 * mu2 * sigma * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda2 * mu1 * sigma * xi ^ 2 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 6 * c * lambda1 ^ 2 * sigma - 6 * c * lambda1 * sigma * xi - 6 * c * lambda2 ^ 2 * sigma - 6 * c * lambda2 * sigma * xi + 12 * lambda1 ^ 2 * mu2 * sigma - 24 * lambda1 * lambda2 * mu1 * sigma + 48 * lambda1 * lambda2 * mu2 * sigma + 24 * lambda1 * mu1 * sigma * xi - 36 * lambda1 * mu2 * sigma * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda2 * mu1 * sigma * xi - 36 * lambda2 * mu2 * sigma * xi + 6 * c * lambda1 * sigma + 6 * c * lambda2 * sigma - 24 * lambda1 * mu1 * sigma + 36 * lambda1 * mu2 * sigma - 24 * lambda2 * mu1 * sigma + 36 * lambda2 * mu2 * sigma) * exp((2 * xi)) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) - (6 * c * lambda1 * sigma * xi) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi)) / 0.2e1;
   x0=-(1/2)*(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1-6*alpha*c*l^3*mu1-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2+3*alpha^2*c^2*l*s2-3*alpha^2*l^3*mu1*mu2-3*alpha^2*l^2*mu1*mu2-6*l^3*mu1*mu2-6*l^2*mu1*mu2+9*c^2-alpha^3*l^3*mu1*mu2-alpha^3*l^2*mu1*mu2-6*alpha*l^3*mu1*mu2-6*alpha*l^2*mu1*mu2+3*alpha^2*c^2+9*c^2*l-18*c*mu1+9*alpha*c^2+3*c^2*l^2+alpha^2*c^2*l^2-6*c*l^3*mu1-12*c*l^2*mu1+6*c*l^2*mu2+3*alpha*c^2*l^2+6*alpha^2*c*l*mu2*s2-9*alpha^2*c*l*mu1+6*alpha^2*c*l*mu2+6*alpha^2*c*mu2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-18*alpha*c*l*mu1+18*alpha*c*l*mu2-18*alpha*c*mu1+18*alpha*c*mu2+18*mu2*c+3*alpha^2*c^2*l+3*alpha^2*c^2*s2-9*alpha^2*c*mu1+6*alpha^2*c*mu2-18*c*l*mu1+18*c*l*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*mu1+9*alpha*c^2*l+(alpha^3*c^2*l^2*s2-alpha^3*c*l^3*mu1+2*alpha^3*c*l^2*mu2*s2-alpha^3*l^3*mu1*mu2+3*alpha^3*c^2*l*s2-2*alpha^3*c*l^2*mu1+6*alpha^3*c*l*mu2*s2-alpha^3*l^2*mu1*mu2-alpha^2*c^2*l^2*s2+3*alpha^2*c*l^3*mu1-2*alpha^2*c*l^2*mu2*s2+3*alpha^2*l^3*mu1*mu2+3*alpha^3*c^2*s2-3*alpha^3*c*l*mu1+6*alpha^3*c*mu2*s2-alpha^2*c^2*l^2-3*alpha^2*c^2*l*s2+6*alpha^2*c*l^2*mu1-2*alpha^2*c*l^2*mu2-6*alpha^2*c*l*mu2*s2+3*alpha^2*l^2*mu1*mu2-6*alpha*c*l^3*mu1-6*alpha*l^3*mu1*mu2-3*alpha^3*c*mu1-3*alpha^2*c^2*l-3*alpha^2*c^2*s2+9*alpha^2*c*l*mu1-6*alpha^2*c*l*mu2-6*alpha^2*c*mu2*s2+3*alpha*c^2*l^2-12*alpha*c*l^2*mu1+6*alpha*c*l^2*mu2-6*alpha*l^2*mu1*mu2+6*c*l^3*mu1+6*l^3*mu1*mu2-3*alpha^2*c^2+9*alpha^2*c*mu1-6*alpha^2*c*mu2+9*alpha*c^2*l-18*alpha*c*l*mu1+18*alpha*c*l*mu2-3*c^2*l^2+12*c*l^2*mu1-6*c*l^2*mu2+6*l^2*mu1*mu2+9*alpha*c^2-18*alpha*c*mu1+18*alpha*c*mu2-9*c^2*l+18*c*l*mu1-18*c*l*mu2-9*c^2+18*c*mu1-18*c*mu2)*exp(2*alpha)+2*alpha^2*c*l^2*mu2*s2+2*alpha^3*c*l^2*mu2*s2+6*alpha^3*c*l*mu2*s2+alpha^2*c^2*l^2*s2-3*alpha^2*c*l^3*mu1-6*alpha^2*c*l^2*mu1+2*alpha^2*c*l^2*mu2)/(l^2*((alpha^3*c^2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+2*alpha^3*l*mu1*mu2+alpha^3*c*mu1+2*alpha^3*mu1*mu2+3*alpha^2*c^2*l-alpha^2*c^2*s2-6*alpha^2*c*l*mu1+9*alpha^2*c*l*mu2-2*alpha^2*c*mu2*s2-6*alpha^2*l*mu1*mu2+6*alpha^2*l*mu2^2+2*alpha^2*c^2-3*alpha^2*c*mu1+7*alpha^2*c*mu2-6*alpha^2*mu1*mu2+6*alpha^2*mu2^2-9*alpha*c^2*l+12*alpha*c*l*mu1-27*alpha*c*l*mu2+12*alpha*l*mu1*mu2-18*alpha*l*mu2^2-6*alpha*c^2+6*alpha*c*mu1-21*alpha*c*mu2+12*alpha*mu1*mu2-18*alpha*mu2^2+9*c^2*l-12*c*l*mu1+27*c*l*mu2-12*l*mu1*mu2+18*l*mu2^2+6*c^2-6*c*mu1+21*c*mu2-12*mu1*mu2+18*mu2^2)*exp(2*alpha)-6*alpha^2*l*mu2^2+6*alpha^2*mu1*mu2+12*l*mu1*mu2-6*alpha^2*mu2^2-18*l*mu2^2+12*mu1*mu2-6*c^2+2*alpha^3*l*mu1*mu2+12*alpha*l*mu1*mu2-2*alpha^2*c^2-9*c^2*l+6*c*mu1-6*alpha*c^2-18*alpha*mu2^2+2*alpha^3*mu1*mu2-18*alpha*l*mu2^2+12*alpha*mu1*mu2+6*alpha^2*l*mu1*mu2+6*alpha^2*c*l*mu1-9*alpha^2*c*l*mu2+2*alpha^2*c*mu2*s2+2*alpha^3*c*l*mu1+2*alpha^3*c*mu2*s2+12*alpha*c*l*mu1-27*alpha*c*l*mu2+6*alpha*c*mu1-21*alpha*c*mu2-21*mu2*c-18*mu2^2-3*alpha^2*c^2*l+alpha^2*c^2*s2+3*alpha^2*c*mu1-7*alpha^2*c*mu2+12*c*l*mu1-27*c*l*mu2+alpha^3*c^2*s2+alpha^3*c*mu1-9*alpha*c^2*l));
   val =(3/(4*pi*sigma^2*(rho1-1 -3*x1)))/(1/(2*(2+c)*pi*x0));
   %val =(3/(4*pi*sigma^2*(rho1-1 -3*x1)));
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function ilt = talbot_inversion(F, t, M)
    % TALBOT_INVERSION
    % Numerical inverse Laplace transform using the fixed Talbot method
    %
    % ilt = talbot_inversion(F, t, M)
    %
    % Inputs:
    %   F : function handle representing F(s)
    %   t : scalar or vector of positive time values
    %   M : number of Talbot terms, default = 64
    %
    % Output:
    %   ilt : numerical inverse Laplace transform at t

    % Default number of terms
    if nargin < 3
        M = 64;
    end

    % Preserve the original shape of t
    original_size = size(t);

    % Convert t to a column vector
    t = t(:);

    % Check that all time values are positive
    if any(t <= 0)
        error('All time values must be positive.');
    end

    % Preallocate result
    ilt = zeros(length(t), 1);

    % Talbot contour angles
    k = 1:(M-1);
    theta = (pi/M) * k;
    cot_theta = cot(theta);

    % Talbot contour parameters
    delta = zeros(1, M);

    % Correct first contour point
    delta(1) = 2*M/5;

    delta(2:end) = ...
        (2*M/5) * theta .* (cot_theta + 1i);

    % Talbot weights
    gamma = zeros(1, M);
    gamma(1) = 0.5 * exp(delta(1));
    gamma(2:end) = ...
        (1 ...
        + 1i*theta.*(1 + cot_theta.^2) ...
        - 1i*cot_theta) ...
        .* exp(delta(2:end));
    % Evaluate the inverse transform
    for i = 1:length(t)
        s_vals = delta / t(i);
        f_vals = arrayfun(F, s_vals);
        ilt(i) = ...
            (0.4/t(i)) * sum(real(gamma .* f_vals));
    end
    % Restore original shape
    ilt = reshape(ilt, original_size);
end

Answer 2

[Torsten]

According to the final value theorem, it holds that

lim (t -> Inf) f(t) = lim (s -> 0) [s*F(s)]

Where:

• t is the time in the time domain.
• f(t) is the inverse Laplace transform of F(s).
• s is the complex frequency variable.
• F(s) is the function in the Laplace domain.

Important Condition:

This formula only works if all the poles (roots of the denominator) of F(s) have negative real parts. If any pole is zero or positive, the function f(t) will not reach a steady-state value. [1, 2, 3, 4, 5]

So if the condition is fulfilled in your case, you can use the below code to compute an approximation of the steady-state value of your inverse Laplace transform for

F(s) = 3/(4*pi*s^2*(rho1-1 -3*x1))

With symbolic math, you might even be able to deduce an explicit formula for lim(s->0) [s*F(s)] (using MATLAB's "limit" function):

https://uk.mathworks.com/help/symbolic/limits.html

sh1()

u_s1 = 
  Columns 1 through 9

   0.0085 - 0.0000i   0.0213 + 0.0000i   0.0313 + 0.0000i   0.0359 + 0.0000i   0.0375 + 0.0000i   0.0381 + 0.0000i   0.0382 + 0.0000i   0.0383 + 0.0000i   0.0383 + 0.0000i

  Column 10

   0.0383 + 0.0000i

u_s1 = 1×10

0.0121 0.0200 0.0245 0.0262 0.0268 0.0270 0.0271 0.0271 0.0271 0.0271

<mw-icon class=""></mw-icon>

<mw-icon class=""></mw-icon>

u_s1 = 1×10

0.0110 0.0169 0.0200 0.0212 0.0216 0.0217 0.0217 0.0218 0.0218 0.0218

<mw-icon class=""></mw-icon>

<mw-icon class=""></mw-icon>

u_s1 = 1×10

0.0091 0.0128 0.0146 0.0152 0.0154 0.0155 0.0155 0.0155 0.0155 0.0155

<mw-icon class=""></mw-icon>

<mw-icon class=""></mw-icon>

function sh1()
clc; close all;
    t_values = [1 1e-1 1e-2 1e-3 1e-4 1e-5 1e-6 1e-7 1e-8 1e-9];
    c_vals = [1, 4, 6, 10]; % 4 specific curves to compare
    params = struct('s1',2, 'rho1',0,'s2',0, 'alpha',1, 'j',0.1,'mu1',1,'mu2',0.001);
    for k = 1:length(c_vals)
        params.c = c_vals(k);
        u_s1 = arrayfun(@(t_values)U_func_s1(t_values,params),t_values)
    end
end
% --- Rename your existing logic to avoid conflicts ---
function val = U_func_s1(sigma, p)
    % Copy your logic from the original calc_s1.m U_function here
    % Ensure it returns 'val'
    % Unpack1
    s1 = p.s1; alpha=p.alpha; 
    s2 = p.s2; c = p.c; j = p.j; rho1 = p.rho1; 
    mu2=p.mu2; mu1=p.mu1;
    % Define S (sum) and P (product)
    xi=sqrt(alpha^2+sigma);
    l = sqrt(c*s1*(2+c)/(1+c));
    % Calculate roots
    S0 = l^2 + (sigma * (1 + j * s1 * (1 + c))) / (1 + c);
    P0 = (sigma * s1 * (4 * c + j * sigma)) / (1 + c);  
    lambda1 = sqrt((S0 - sqrt(S0^2 - 4*P0)) / 2);
    lambda2 = sqrt((S0 + sqrt(S0^2 - 4*P0)) / 2);
   x1 = -(-(72 * lambda1 ^ 2 * lambda2 * mu1) - (72 * lambda1 * lambda2 ^ 2 * mu1) - (36 * lambda1 * mu1 * xi ^ 2) + (24 * lambda1 * mu2 * xi ^ 2) - (36 * lambda2 * mu1 * xi ^ 2) + (24 * lambda2 * mu2 * xi ^ 2) + (72 * c * lambda1 * lambda2 * xi) + (12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) - (72 * c * lambda2 * mu1) + (72 * c * lambda2 * mu2) + (72 * c * lambda1 * mu2) - (72 * c * lambda2 ^ 2 * mu1) + (72 * c * lambda2 ^ 2 * mu2) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (36 * c ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (72 * lambda2 * mu1) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (24 * lambda1 * lambda2 * mu1 * xi ^ 3) - (144 * lambda1 * lambda2 * mu1) - (72 * lambda1 ^ 2 * mu1) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (12 * c * lambda2 * mu1 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * lambda1 * mu1 * xi ^ 3) - (12 * lambda2 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2) + (72 * lambda2 ^ 2 * mu2) + (72 * lambda1 * mu2) + (72 * lambda2 * mu2) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) - (24 * c * lambda1 * lambda2 * mu1 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1) + (72 * c * lambda1 ^ 2 * mu2) + (144 * c * lambda1 * lambda2 * mu2) + (36 * c ^ 2 * lambda1 ^ 2 * xi) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (36 * c ^ 2 * lambda1 ^ 2 * lambda2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2) + (12 * c ^ 2 * lambda1 * xi ^ 2) + (12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda2 * xi ^ 2) + (36 * c * lambda1 * xi) + (36 * c * lambda2 * xi) + (36 * c ^ 2 * lambda2) + (36 * c ^ 2 * lambda1) + (24 * c * lambda1 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 3) + (36 * c ^ 2 * lambda1 ^ 2) + (36 * c ^ 2 * lambda2 ^ 2) + (72 * c ^ 2 * lambda1 * lambda2) + (36 * c * lambda2 ^ 2) + (36 * c * lambda1) + (36 * c * lambda2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (6 * c * lambda1 * s2 * xi ^ 3) + (6 * c * lambda2 * s2 * xi ^ 3) + (3 * c ^ 2 * lambda2 * s2 * xi ^ 2) + (72 * c ^ 2 * lambda1 * lambda2 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2) - (36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) - (72 * lambda2 ^ 2 * mu1 * xi) + (72 * lambda2 ^ 2 * mu2 * xi) - (12 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * c * lambda2 * mu1 * xi) + (72 * c * lambda2 * mu2 * xi) - (144 * c * lambda1 * lambda2 * mu1) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2) - (36 * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * lambda2 ^ 2 * mu2 * xi ^ 2) + (24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2) + (12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) + (6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) - (144 * lambda1 * lambda2 * mu1 * xi) + (144 * lambda1 * lambda2 * mu2 * xi) + (72 * lambda1 * lambda2 ^ 2 * mu2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * lambda1 * lambda2 ^ 2 * mu1 * xi) - (72 * lambda1 ^ 2 * lambda2 * mu1 * xi) + (36 * c * lambda1 ^ 2 * lambda2) + (36 * c * lambda1 * lambda2 ^ 2) + (72 * c * lambda1 * lambda2) - (36 * c * lambda2 * mu1 * xi ^ 2) + (24 * c * lambda2 * mu2 * xi ^ 2) + (24 * c * lambda1 * mu2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2) - (72 * c * lambda1 * lambda2 ^ 2 * mu1) - (72 * c * lambda1 ^ 2 * lambda2 * mu1) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) - (72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi) - (72 * lambda1 * mu1 * xi) + (72 * lambda1 * mu2 * xi) - (72 * lambda2 * mu1 * xi) + (72 * lambda2 * mu2 * xi) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (6 * c * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * lambda1 ^ 2 * xi ^ 3 * mu1) - (36 * lambda1 ^ 2 * xi ^ 2 * mu1) - (72 * lambda1 ^ 2 * mu1 * xi) + (24 * lambda1 ^ 2 * mu2 * xi ^ 2) + (72 * lambda1 ^ 2 * mu2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2) - (36 * c * lambda1 * mu1 * xi ^ 2) + (48 * c * lambda1 * lambda2 * mu2 * xi ^ 2) - (144 * c * lambda1 * lambda2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (36 * c ^ 2 * lambda1 * xi) + (36 * c ^ 2 * lambda2 * xi) + (3 * c ^ 2 * lambda1 * s2 * xi ^ 2) - (12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (72 * lambda1 * mu1) - (72 * lambda2 ^ 2 * mu1) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (36 * c * lambda2 ^ 2 * mu1 * xi ^ 2) + (24 * c * lambda2 ^ 2 * mu2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * lambda2 * xi) + (36 * c * lambda1 * lambda2 ^ 2 * xi) - (72 * c * lambda2 ^ 2 * mu1 * xi) + (72 * c * lambda2 ^ 2 * mu2 * xi) + (6 * c * lambda1 * mu2 * s2 * xi ^ 2) + (6 * c * lambda2 * mu2 * s2 * xi ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) - (12 * c * lambda2 ^ 2 * mu1 * xi ^ 3) + (12 * c ^ 2 * lambda2 * xi ^ 2) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 3) - (6 * c * lambda1 * sigma * xi) - (72 * c * lambda1 * mu1) + (6 * c * lambda1 ^ 2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2) - (72 * c * lambda1 * mu1 * xi) + (72 * c * lambda1 * mu2 * xi) + (6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3) - (12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) + (72 * c * lambda1 ^ 2 * mu2 * xi) + (36 * c * lambda1 ^ 2) + (24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2) + (24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) - (72 * lambda1 * lambda2 * mu1 * xi ^ 2) + (48 * lambda1 * lambda2 * mu2 * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3) - (12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3) - (36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2) + (24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2) - (36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (24 * c * lambda1 * lambda2 * xi ^ 2) + (6 * c * lambda1 * s2 * xi ^ 2) + (6 * c * lambda2 * s2 * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi) - (12 * c * lambda1 * mu1 * xi ^ 3) + (3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2) + (12 * c * lambda2 ^ 2 * xi ^ 2) + (36 * c * lambda2 ^ 2 * xi) + (72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi) - (72 * c * lambda1 * lambda2 * mu1 * xi ^ 2) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * mu1 * xi ^ 3) + (12 * c * lambda1 * xi ^ 2) - (36 * c * lambda1 ^ 2 * mu1 * xi ^ 2) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) + (6 * c * lambda1 * mu2 * s2 * xi ^ 3) + (6 * c * lambda2 * mu2 * s2 * xi ^ 3) - (72 * c * lambda1 ^ 2 * mu1 * xi) + (3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3) + (6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2) + (12 * c * lambda1 * lambda2 * s2 * xi ^ 2) + (3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2) + (72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi) - (72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi) + (144 * c * lambda1 * lambda2 * mu2 * xi) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (72 * lambda1 ^ 2 * lambda2 * mu2) + (72 * lambda1 * lambda2 ^ 2 * mu2) + (144 * lambda1 * lambda2 * mu2) + (12 * c * lambda1 ^ 2 * xi ^ 2) + (36 * c * lambda1 ^ 2 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 3 + 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 + 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 3 + 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 12 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * lambda2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 3 - 12 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 3 + 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 + 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 ^ 2 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi ^ 2 - 6 * c ^ 2 * lambda1 * lambda2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda1 * s2 * xi ^ 3 - 3 * c ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 + 3 * c ^ 2 * lambda2 * s2 * xi ^ 3 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 12 * c * lambda1 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda1 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda1 ^ 2 * s2 * xi ^ 3 + 36 * c * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 - 24 * c * lambda1 * lambda2 * mu1 * xi ^ 3 - 12 * c * lambda1 * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 + 12 * c * lambda1 * lambda2 * s2 * xi ^ 3 + 6 * c * lambda1 * mu2 * s2 * xi ^ 3 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 12 * c * lambda2 ^ 2 * mu1 * xi ^ 3 - 6 * c * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 6 * c * lambda2 ^ 2 * s2 * xi ^ 3 + 6 * c * lambda2 * mu2 * s2 * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 3 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda1 ^ 2 * lambda2 * xi - 12 * c ^ 2 * lambda1 ^ 2 * xi ^ 2 + 36 * c ^ 2 * lambda1 * lambda2 ^ 2 * xi - 24 * c ^ 2 * lambda1 * lambda2 * xi ^ 2 - 3 * c ^ 2 * lambda1 * s2 * xi ^ 2 - 12 * c ^ 2 * lambda2 ^ 2 * xi ^ 2 - 3 * c ^ 2 * lambda2 * s2 * xi ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi - 72 * c * lambda1 ^ 2 * lambda2 * mu1 * xi + 72 * c * lambda1 ^ 2 * lambda2 * mu2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 12 * c * lambda1 ^ 2 * lambda2 * xi ^ 2 + 36 * c * lambda1 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda1 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda1 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 - 72 * c * lambda1 * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda1 * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi - 12 * c * lambda1 * lambda2 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * c * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * c * lambda1 * lambda2 * s2 * xi ^ 2 - 12 * c * lambda1 * mu1 * xi ^ 3 - 6 * c * lambda1 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 * s2 * sigma * xi ^ 2 + 6 * c * lambda1 * s2 * xi ^ 3 + 36 * c * lambda2 ^ 2 * mu1 * xi ^ 2 - 24 * c * lambda2 ^ 2 * mu2 * xi ^ 2 - 6 * c * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 - 12 * c * lambda2 * mu1 * xi ^ 3 - 6 * c * lambda2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 + 6 * c * lambda2 * s2 * xi ^ 3 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi + 36 * lambda1 ^ 2 * lambda2 * mu1 * xi ^ 2 - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 ^ 2 * xi ^ 3 * mu1 + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 + 36 * lambda1 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda1 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 - 24 * lambda1 * lambda2 * mu1 * xi ^ 3 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 - 12 * lambda2 ^ 2 * mu1 * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 36 * c ^ 2 * lambda1 ^ 2 * lambda2 + 36 * c ^ 2 * lambda1 ^ 2 * xi - 36 * c ^ 2 * lambda1 * lambda2 ^ 2 + 72 * c ^ 2 * lambda1 * lambda2 * xi - 12 * c ^ 2 * lambda1 * xi ^ 2 + 36 * c ^ 2 * lambda2 ^ 2 * xi - 12 * c ^ 2 * lambda2 * xi ^ 2 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 + 72 * c * lambda1 ^ 2 * lambda2 * mu1 - 72 * c * lambda1 ^ 2 * lambda2 * mu2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 36 * c * lambda1 ^ 2 * lambda2 * xi - 72 * c * lambda1 ^ 2 * mu1 * xi + 72 * c * lambda1 ^ 2 * mu2 * xi + 6 * c * lambda1 ^ 2 * sigma * xi - 12 * c * lambda1 ^ 2 * xi ^ 2 + 72 * c * lambda1 * lambda2 ^ 2 * mu1 - 72 * c * lambda1 * lambda2 ^ 2 * mu2 - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 36 * c * lambda1 * lambda2 ^ 2 * xi - 144 * c * lambda1 * lambda2 * mu1 * xi + 144 * c * lambda1 * lambda2 * mu2 * xi - 24 * c * lambda1 * lambda2 * xi ^ 2 + 36 * c * lambda1 * mu1 * xi ^ 2 - 24 * c * lambda1 * mu2 * xi ^ 2 - 6 * c * lambda1 * s2 * xi ^ 2 + 2 * c * lambda1 * sigma * xi ^ 2 - 72 * c * lambda2 ^ 2 * mu1 * xi + 72 * c * lambda2 ^ 2 * mu2 * xi + 6 * c * lambda2 ^ 2 * sigma * xi - 12 * c * lambda2 ^ 2 * xi ^ 2 + 36 * c * lambda2 * mu1 * xi ^ 2 - 24 * c * lambda2 * mu2 * xi ^ 2 - 6 * c * lambda2 * s2 * xi ^ 2 + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 - 72 * lambda1 ^ 2 * lambda2 * mu1 * xi + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma + 72 * lambda1 ^ 2 * lambda2 * mu2 * xi + 36 * lambda1 ^ 2 * xi ^ 2 * mu1 - 12 * lambda1 ^ 2 * mu2 * sigma * xi - 24 * lambda1 ^ 2 * mu2 * xi ^ 2 - 72 * lambda1 * lambda2 ^ 2 * mu1 * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda1 * lambda2 ^ 2 * mu2 * xi + 24 * lambda1 * lambda2 * mu1 * sigma * xi + 72 * lambda1 * lambda2 * mu1 * xi ^ 2 - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * xi ^ 2 - 12 * lambda1 * mu1 * sigma * xi ^ 2 - 12 * lambda1 * mu1 * xi ^ 3 + 12 * lambda1 * mu2 * sigma * xi ^ 2 + 36 * lambda2 ^ 2 * mu1 * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 24 * lambda2 ^ 2 * mu2 * xi ^ 2 - 12 * lambda2 * mu1 * sigma * xi ^ 2 - 12 * lambda2 * mu1 * xi ^ 3 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 36 * c ^ 2 * lambda1 ^ 2 - 72 * c ^ 2 * lambda1 * lambda2 + 36 * c ^ 2 * lambda1 * xi - 36 * c ^ 2 * lambda2 ^ 2 + 36 * c ^ 2 * lambda2 * xi - 36 * c * lambda1 ^ 2 * lambda2 + 72 * c * lambda1 ^ 2 * mu1 - 72 * c * lambda1 ^ 2 * mu2 - 6 * c * lambda1 ^ 2 * sigma + 36 * c * lambda1 ^ 2 * xi - 36 * c * lambda1 * lambda2 ^ 2 + 144 * c * lambda1 * lambda2 * mu1 - 144 * c * lambda1 * lambda2 * mu2 + 72 * c * lambda1 * lambda2 * xi - 72 * c * lambda1 * mu1 * xi + 72 * c * lambda1 * mu2 * xi - 6 * c * lambda1 * sigma * xi - 12 * c * lambda1 * xi ^ 2 + 72 * c * lambda2 ^ 2 * mu1 - 72 * c * lambda2 ^ 2 * mu2 - 6 * c * lambda2 ^ 2 * sigma + 36 * c * lambda2 ^ 2 * xi - 72 * c * lambda2 * mu1 * xi + 72 * c * lambda2 * mu2 * xi - 6 * c * lambda2 * sigma * xi - 12 * c * lambda2 * xi ^ 2 + 72 * lambda1 ^ 2 * lambda2 * mu1 - 72 * lambda1 ^ 2 * lambda2 * mu2 - 72 * lambda1 ^ 2 * mu1 * xi + 12 * lambda1 ^ 2 * mu2 * sigma + 72 * lambda1 ^ 2 * mu2 * xi + 72 * lambda1 * lambda2 ^ 2 * mu1 - 72 * lambda1 * lambda2 ^ 2 * mu2 - 24 * lambda1 * lambda2 * mu1 * sigma - 144 * lambda1 * lambda2 * mu1 * xi + 48 * lambda1 * lambda2 * mu2 * sigma + 144 * lambda1 * lambda2 * mu2 * xi + 24 * lambda1 * mu1 * sigma * xi + 36 * lambda1 * mu1 * xi ^ 2 - 36 * lambda1 * mu2 * sigma * xi - 24 * lambda1 * mu2 * xi ^ 2 - 72 * lambda2 ^ 2 * mu1 * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 72 * lambda2 ^ 2 * mu2 * xi + 24 * lambda2 * mu1 * sigma * xi + 36 * lambda2 * mu1 * xi ^ 2 - 36 * lambda2 * mu2 * sigma * xi - 24 * lambda2 * mu2 * xi ^ 2 - 36 * c ^ 2 * lambda1 - 36 * c ^ 2 * lambda2 - 36 * c * lambda1 ^ 2 - 72 * c * lambda1 * lambda2 + 72 * c * lambda1 * mu1 - 72 * c * lambda1 * mu2 + 6 * c * lambda1 * sigma + 36 * c * lambda1 * xi - 36 * c * lambda2 ^ 2 + 72 * c * lambda2 * mu1 - 72 * c * lambda2 * mu2 + 6 * c * lambda2 * sigma + 36 * c * lambda2 * xi + 72 * lambda1 ^ 2 * mu1 - 72 * lambda1 ^ 2 * mu2 + 144 * lambda1 * lambda2 * mu1 - 144 * lambda1 * lambda2 * mu2 - 24 * lambda1 * mu1 * sigma - 72 * lambda1 * mu1 * xi + 36 * lambda1 * mu2 * sigma + 72 * lambda1 * mu2 * xi + 72 * lambda2 ^ 2 * mu1 - 72 * lambda2 ^ 2 * mu2 - 24 * lambda2 * mu1 * sigma - 72 * lambda2 * mu1 * xi + 36 * lambda2 * mu2 * sigma + 72 * lambda2 * mu2 * xi - 36 * c * lambda1 - 36 * c * lambda2 + 72 * lambda1 * mu1 - 72 * lambda1 * mu2 + 72 * lambda2 * mu1 - 72 * lambda2 * mu2) * exp((2 * xi))) / (-(12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) - (4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2) - (4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma) + (12 * lambda1 * mu1 * sigma * xi ^ 2) - (12 * lambda1 * mu2 * sigma * xi ^ 2) + (12 * lambda2 * mu1 * sigma * xi ^ 2) - (12 * lambda2 * mu2 * sigma * xi ^ 2) + (24 * lambda1 * lambda2 * mu1 * sigma) - (48 * lambda1 * lambda2 * mu2 * sigma) + (4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * sigma) + (6 * c * lambda2 ^ 2 * sigma) - (6 * c * lambda1 * sigma) - (6 * c * lambda2 * sigma) - (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) - (4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2) + (12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2) - (16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2) - (4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3) + (24 * lambda1 * lambda2 * mu1 * sigma * xi) - (48 * lambda1 * lambda2 * mu2 * sigma * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3 - c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2 + 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3 - 4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2 - 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3 - 4 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 3 + 12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2 - 2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2 - 2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2 - 2 * c * lambda1 * s2 * sigma * xi ^ 3 - 2 * c * lambda2 * s2 * sigma * xi ^ 3 + 12 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2 - 8 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2 + 4 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2 + 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi + 6 * c * lambda1 ^ 2 * lambda2 * sigma * xi - 2 * c * lambda1 ^ 2 * sigma * xi ^ 2 + 6 * c * lambda1 * lambda2 ^ 2 * sigma * xi + 2 * c * lambda1 * s2 * sigma * xi ^ 2 - 2 * c * lambda2 ^ 2 * sigma * xi ^ 2 + 2 * c * lambda2 * s2 * sigma * xi ^ 2 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi - 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi + 4 * lambda1 ^ 2 * mu2 * sigma * xi ^ 2 - 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda1 * lambda2 * mu1 * sigma * xi ^ 2 + 16 * lambda1 * lambda2 * mu2 * sigma * xi ^ 2 + 4 * lambda1 * mu1 * sigma * xi ^ 3 + 4 * lambda2 ^ 2 * mu2 * sigma * xi ^ 2 + 4 * lambda2 * mu1 * sigma * xi ^ 3 - 12 * lambda1 ^ 2 * c * lambda2 ^ 2 - 6 * c * lambda1 ^ 2 * lambda2 * sigma + 6 * c * lambda1 ^ 2 * sigma * xi - 6 * c * lambda1 * lambda2 ^ 2 * sigma + 2 * c * lambda1 * sigma * xi ^ 2 + 6 * c * lambda2 ^ 2 * sigma * xi + 2 * c * lambda2 * sigma * xi ^ 2 + 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 - 24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 + 12 * lambda1 ^ 2 * lambda2 * mu2 * sigma - 12 * lambda1 ^ 2 * mu2 * sigma * xi + 12 * lambda1 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda1 * lambda2 * mu1 * sigma * xi - 48 * lambda1 * lambda2 * mu2 * sigma * xi - 12 * lambda1 * mu1 * sigma * xi ^ 2 + 12 * lambda1 * mu2 * sigma * xi ^ 2 - 12 * lambda2 ^ 2 * mu2 * sigma * xi - 12 * lambda2 * mu1 * sigma * xi ^ 2 + 12 * lambda2 * mu2 * sigma * xi ^ 2 - 6 * c * lambda1 ^ 2 * sigma - 6 * c * lambda1 * sigma * xi - 6 * c * lambda2 ^ 2 * sigma - 6 * c * lambda2 * sigma * xi + 12 * lambda1 ^ 2 * mu2 * sigma - 24 * lambda1 * lambda2 * mu1 * sigma + 48 * lambda1 * lambda2 * mu2 * sigma + 24 * lambda1 * mu1 * sigma * xi - 36 * lambda1 * mu2 * sigma * xi + 12 * lambda2 ^ 2 * mu2 * sigma + 24 * lambda2 * mu1 * sigma * xi - 36 * lambda2 * mu2 * sigma * xi + 6 * c * lambda1 * sigma + 6 * c * lambda2 * sigma - 24 * lambda1 * mu1 * sigma + 36 * lambda1 * mu2 * sigma - 24 * lambda2 * mu1 * sigma + 36 * lambda2 * mu2 * sigma) * exp((2 * xi)) - (36 * lambda2 * mu2 * sigma * xi) - (36 * lambda1 * mu2 * sigma * xi) + (24 * lambda2 * mu1 * sigma * xi) + (24 * lambda1 * mu1 * sigma * xi) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) + (4 * lambda1 * mu1 * sigma * xi ^ 3) + (4 * lambda2 * mu1 * sigma * xi ^ 3) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) - (2 * c * lambda2 * s2 * sigma * xi ^ 3) + (6 * c * lambda1 ^ 2 * lambda2 * sigma * xi) + (6 * c * lambda1 * lambda2 ^ 2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 3) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 3) - (12 * lambda1 ^ 2 * mu2 * sigma * xi) - (12 * lambda2 ^ 2 * mu2 * sigma * xi) - (2 * c * lambda1 * s2 * sigma * xi ^ 3) + (12 * lambda1 ^ 2 * c ^ 2 * lambda2 ^ 2) + (12 * lambda1 ^ 2 * c * lambda2 ^ 2) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 3) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi) + (c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) - (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1 * xi ^ 2) + (8 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * xi ^ 2) + (12 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi) + (6 * c * lambda1 ^ 2 * sigma * xi) + (6 * c * lambda2 ^ 2 * sigma * xi) - (6 * c * lambda2 * sigma * xi) + (4 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) - (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * s2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * lambda2 * sigma * xi ^ 2) + (2 * c * lambda1 * lambda2 ^ 2 * sigma * xi ^ 2) - (2 * c * lambda1 * s2 * sigma * xi ^ 2) - (2 * c * lambda2 * s2 * sigma * xi ^ 2) - (6 * c * lambda1 * sigma * xi) - (12 * lambda1 ^ 2 * lambda2 * mu2 * sigma * xi) - (12 * lambda1 * lambda2 ^ 2 * mu2 * sigma * xi) + (2 * c * lambda1 ^ 2 * lambda2 ^ 2 * mu2 * s2 * xi ^ 2) - (2 * c * lambda1 * lambda2 * s2 * sigma * xi ^ 2) + (4 * c * lambda1 ^ 2 * lambda2 ^ 2 * xi ^ 2) + (2 * c * lambda1 ^ 2 * sigma * xi ^ 2) + (2 * c * lambda2 ^ 2 * sigma * xi ^ 2) + (6 * c * lambda1 ^ 2 * lambda2 * sigma) + (6 * c * lambda1 * lambda2 ^ 2 * sigma) - (2 * c * lambda1 * sigma * xi ^ 2) - (2 * c * lambda2 * sigma * xi ^ 2) - (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu1) + (24 * lambda1 ^ 2 * lambda2 ^ 2 * mu2) - (12 * lambda1 ^ 2 * mu2 * sigma) - (12 * lambda2 ^ 2 * mu2 * sigma) + (24 * lambda1 * mu1 * sigma) - (36 * lambda1 * mu2 * sigma) + (24 * lambda2 * mu1 * sigma) - (36 * lambda2 * mu2 * sigma) + (12 * c ^ 2 * lambda1 ^ 2 * lambda2 ^ 2 * xi)) / 0.2e1;
   val = 3/(4*pi*sigma^2*(rho1-1 -3*x1))*sigma;
end

[Shreen El-Sapa]

@Torsten Thanks for your effort. Ca tell me the problem? also all curves should be start from t=0

[Shreen El-Sapa]

@Torsten, How are you get it? all curves should start with 0

[Torsten]

This code computes the steady state of the Inverse Laplace Transform of F(s) = 3/(4*pi*s^2*(rho1-1 -3*x1)) analytically by the formula lim(s->0)[s*F(s)].

Normalizing F(s) by this value, the graphs of f(t) = L^(-1) (F(s)) run between 0 and 1.

run("invl.m")

Warning: Graphics acceleration hardware is unavailable. Graphics quality and performance might be diminished. See MATLAB System Requirements.

[Shreen El-Sapa]

@Torsten Thanks so much. I will apply this code for other different parameters and tell you. Thanks again

[dpb]

@Shreen El-Sapa -- use Comment instead of Answer for feedback posts.

[Shreen El-Sapa]

@dpb--How?

[Paul]

"This formula only works if all the poles (roots of the denominator) of F(s) have negative real parts. If any pole is zero or positive, the function f(t) will not reach a steady-state value."

The formula works if F(s) has a simple pole at the origin.

For example

syms s t
F(s) = 1/s/(s+1); % simple pole at the origin
limit(ilaplace(F(s),s,t),t,inf)  % final value in time domain

ans = 

1

limit(s*F(s),s,0)  % final value theorem

ans = 

1

[Torsten]

@Paul

I took the answer from AI - I also didn't know about the final value theorem before.

What do we learn ? Don't trust AI blindly.

[dpb]

@Shreen El-Sapa To comment instead of creating a new Answer, there's an empty box (should have your user ID) that says "Comment on this Answer" under every Answer posted or "Add a Comment" under prior replies if somebody else has already. Just start typing in it same as in the Answer box...

[Shreen El-Sapa]

Thanks