function [A, n, B, k, Amatrix, eigsSigma, shiftAndInvert, cholB, permB, scaleB, spdB, ...

    innerOpts, randStr, useEig, originalB]  = checkInputs(varargin)

% Process the inputs and get some information from them

% Set the rand stream to make algorithm reproducible

randStr = RandStream('dsfmt19937','Seed',0); 

isrealprob = true; 

ishermprob = false; 

if isa(varargin{1},'double') 

    A = varargin{1}; 

    Amatrix = true; 

    isrealprob = isreal(A); 

    ishermprob = ishermitian(A); 

    [m, n] = size(A); 

    if m ~= n 

        error(message('MATLAB:eigs:NonSquareMatrixOrFunction'));

    end

else

    % By checking the function A with fcnchk, we can now use direct

    % function evaluation on the result, without resorting to feval

    [A, notFunc] = fcnchk(varargin{1});

    Amatrix = false;

    if ~isempty(notFunc)

        error(message('MATLAB:eigs:NonDoubleOrFunction'));

    end

    if nargin < 2

        error(message('MATLAB:eigs:MustHaveSecondInput'));

    end

    n = varargin{2};

    if ~isscalar(n) || ~isreal(n) || n<0 || ~isfinite(n) || round(n) ~= n

        error(message('MATLAB:eigs:NonPosIntSize'));

    end

    n = full(n);

end 

% Process the input B. Is B present in the eigs call or not?

if nargin < 3-Amatrix 

    Bpresent = false;

    B = [];

else 

    % Is the next input B or K?

    Bpresent = isBpresent(varargin{3-Amatrix}, nargin, Amatrix, n); 

    if Bpresent 

        B = varargin{3-Amatrix};

        isrealprob = isrealprob && isreal(B);

    else 

        B = []; 

    end 

end 

% Store the original B before any scaling

originalB = B; 

% argOffset tells us where to get the eigs inputs K, SIGMA and OPTS.

% If A is really the function afun, then it also helps us find the

% trailing parameters in eigs(afun,n,[B],k,sigma,opts,P1,P2,...)

% Values of argOffset:

%  0: Amatrix is false and Bpresent is true:

%     eigs(afun,n,B,k,sigma,opts,P1,P2,...)

%  1: Amatrix and Bpresent are both true, or both false

%     eigs(A,B,k,sigma,opts)

%     eigs(afun,n,k,sigma,opts,P1,P2,...)

%  2: Amatrix is true and Bpresent is false:

%     eigs(A,k,sigma,opts)

argOffset = Amatrix + ~Bpresent; 

% Process the input K

if nargin < 4-argOffset 

    k = min(n,6);

else 

    k = varargin{4-argOffset}; 

    if ~isnumeric(k) || ~isscalar(k) || ~isreal(k) || k>n || ... 

            k<0 || ~isfinite(k) || round(k) ~= k 

        if isnumeric(k) && isscalar(k)

            error(message('MATLAB:eigs:NonIntegerEigQtyDetail', n, num2str(k)));

        elseif ischar(k)

            error(message('MATLAB:eigs:NonIntegerEigQtyDetail', n, ['''' k '''']));

        elseif isstruct(k)

            error(message('MATLAB:eigs:NonIntegerEigQtyStruct', n));

        else

            error(message('MATLAB:eigs:NonIntegerEigQty', n));

        end

    end

    k = double(full(k)); 

end 

% Process the input SIGMA:

% eigsSigma = 'SM' or 0 : sigma = 0, method = 'LM' , shiftAndInvert = true

% eigsSigma is scalar : sigma = eigsSigma, method = 'LM' , shiftAndInvert = true

% otherwise: sigma = 0, method = eigsSigma, shiftAndInvert = false

if nargin < 5-argOffset 

    % set default

    eigsSigma = 'largestabs';

    method = 'largestabs';

    sigma = 0;

    shiftAndInvert = false;

else 

    eigsSigma = varargin{5-argOffset}; 

    if (ischar(eigsSigma) && isrow(eigsSigma)) || (isstring(eigsSigma) && isscalar(eigsSigma)) 

        validSigmasOld = {'LM','SM','LA','LR','SA','SR','BE','LI','SI'};

        validSigmasNew = {'largestabs','smallestabs','largestreal','smallestreal',...

            'bothendsreal','largestimag','smallestimag','bothendsimag'};

        if length(eigsSigma) == 2

            match = startsWith(validSigmasOld, eigsSigma, 'IgnoreCase', true);

            if nnz(match) ~= 1 || strlength(eigsSigma) == 0

                error(message('MATLAB:eigs:InvalidSigma'));

            else

                eigsSigma = validSigmasOld{match};

            end

        else

            match = startsWith(validSigmasNew, eigsSigma, 'IgnoreCase', true);

            if nnz(match) ~= 1 || strlength(eigsSigma) == 0

                error(message('MATLAB:eigs:InvalidSigma'));

            else

                eigsSigma = validSigmasNew{match};

            end

        end

        if ismember(eigsSigma,{'SM','smallestabs'})

            eigsSigma = 'smallestabs';

            method = 'largestabs';

            shiftAndInvert = true;

        else

            % Allow old sigma values to flow through. Will convert 'LI' and

            % 'SI' in extraChecks once we have the required info

            if strcmp(eigsSigma,'LM')

                eigsSigma = 'largestabs';

            elseif ismember(eigsSigma,{'LA','LR'})

                eigsSigma = 'largestreal';

            elseif ismember(eigsSigma,{'SA','SR'})

                eigsSigma = 'smallestreal';

            elseif strcmp(eigsSigma,'BE')

                eigsSigma = 'bothendsreal';

            end

            method = eigsSigma;

            shiftAndInvert = false;

        end

        sigma = 0;

    elseif isfloat(eigsSigma) && isscalar(eigsSigma) 

        % SIGMA is a scalar

        eigsSigma = double(full(eigsSigma)); 

        sigma = eigsSigma; 

        isrealprob = isrealprob && isreal(sigma); 

        method = 'largestabs'; 

        shiftAndInvert = true; 

    else

        error(message('MATLAB:eigs:InvalidSigma'));

    end 

end 

% Set defaults for input options

tol = 1e-14; 

maxit = 300; 

p =  min(max(2*k,20),n); 

userp = false; % logical -- did the user set option p? 

v0 = randn(randStr, n,1); 

fail = 'replacenan'; 

disp = 0; 

cholB = false; 

permB = []; 

spdB = []; 

% Process the input options struct

NameValueFlag = false; 

optsStart = 6-argOffset; 

if nargin >= optsStart 

    if isstruct(varargin{optsStart})

        opts = varargin{optsStart};

        if nargin > optsStart

            if Amatrix

                error(message('MATLAB:eigs:TooManyInputs'));

            else

                % Add trailing parameters into function handle A

                args = varargin(7-argOffset:nargin);

                A = createAfun(A, args{:});

            end

        end

    else

        % Convert name-value pairs to struct for ease of error checking

        NameValueFlag = true;

        for j = optsStart:2:length(varargin)

            name = varargin{j};

            if (~(ischar(name) && isrow(name)) && ~(isstring(name) && isscalar(name))) ...

                    || (isstring(name) && strlength(name) == 0)

                error(message('MATLAB:eigs:ParseFlags'));

            end

            nvNames = ["IsFunctionSymmetric", "Tolerance", "MaxIterations", ...

                "SubspaceDimension", "StartVector", "IsSymmetricDefinite", ...

                "IsCholesky", "CholeskyPermutation", "FailureTreatment", ...

                "Display"];

            structNames = {'issym','tol','maxit','p','v0','spdB','cholB','permB','fail','disp'};

            ind = startsWith(nvNames, name, 'IgnoreCase', true);

            if nnz(ind) ~= 1

                error(message('MATLAB:eigs:ParseFlags'));

            end

            if j+1 > length(varargin)

                error(message('MATLAB:eigs:KeyWithoutValue'));

            end

            opts.(structNames{ind}) = varargin{j+1};

        end

    end

    % Check option for AFUN: issym and isreal

    if isfield(opts,'issym')

        ishermprob = checkIsSym(opts.issym, ishermprob, Amatrix, NameValueFlag);

    end

    if isfield(opts,'isreal') && ~Amatrix

        % opts.isreal is an old option that is now only used with inputs

        % 'si' or 'li', to determine to which new sigma value they

        % translate.

        if ~isscalar(opts.isreal) || (opts.isreal ~= true && opts.isreal ~= false)

            error(message('MATLAB:eigs:InvalidOptsIsreal'));

        end

        isrealprob = isrealprob && opts.isreal;

    end

    % Check options for algorithm: tol, p, maxit, v0, and fail

    if isfield(opts,'tol')

        tol = checkTol(opts.tol, NameValueFlag);

    end

    if isfield(opts,'p')

        p = checkP(opts.p, n, k, NameValueFlag);

        userp = true;

    end

    if isfield(opts,'maxit')

        maxit = checkMaxit(opts.maxit, NameValueFlag);

    end

    if isfield(opts,'v0')

        v0 = checkV0(opts.v0, n, NameValueFlag);

        isrealprob = isrealprob && isreal(v0);

    end

    if isfield(opts, 'fail')

        fail = checkFail(opts.fail, NameValueFlag);

    end

    if isfield(opts, 'disp')

        disp = checkDisp(opts.disp, NameValueFlag);

    end

    % Check options for B: cholB, permB and spdB

    if ~isempty(B) && isfield(opts,'cholB')

        cholB = checkCholB(opts.cholB, B, NameValueFlag);

        if isfield(opts,'permB')

            % Note, permB is silently ignored if user does not give cholB

            permB = checkPermB(opts.permB, cholB, issparse(B), n, NameValueFlag);

        end

    end

    if ~isempty(B) && isfield(opts, 'spdB')

        spdB = checkSPDB(opts.spdB, B, cholB, NameValueFlag);

    end

end

if p >= n || k == 0 

    % Since we are going to build the whole subspace anyway, just use

    % full eig. Ignore starting vector and InnerOpts.

    useEig = true;

else 

    useEig = false; 

end 

% Scale the matrix B, if needed

if ~isempty(B) 

    scaleB = norm(B,'fro')./sqrt(n);

    scaleB = 2.^floor(log2(scaleB+1));

    B = B./scaleB;

    if cholB

        scaleB = scaleB.^2;

    end

    if isscalar(eigsSigma)

        sigma = scaleB.*eigsSigma;

    end

else 

    scaleB = []; 

end 

% Create an inner options struct to carry around values

innerOpts = struct('tol', tol, 'maxit', maxit, 'p', p, 'v0', v0, 'method',... 

    method, 'sigma', sigma, 'ishermprob', ishermprob, 'isrealprob', isrealprob, ... 

    'fail', fail, 'disp', disp, 'userp', userp); 

end