function [c,indA,indC] = uniqueR2012a(a,options)

% 'R2012a' flag implementaion

% flagvals = {'rows' 'first' 'last' 'sorted' 'stable'};

if nargin == 1 

    byrow = false;

    order = 'sorted';

else 

    byrow = (options(1) > 0); 

    if options(5) > 0 

        order = 'stable';

    elseif options(3) > 0 

        order = 'last';

    else % if options(4) > 0 || options(2) || sum(options(2:5) == 0)   

        order = 'sorted';   %'first' and 'sorted' do the same thing 

    end 

end 

% Determine if A is a row vector.

rowvec = isrow(a); 

if ~byrow  % default case 

    % Convert to column

    a = a(:); 

    numelA = numel(a); 

    % Sort A and get the indices if needed.

    isSortedA = false;  

    if isnumeric(a) && ~isobject(a) 

       isSortedA = issorted(a);  

    end 

    if nargout > 1 || strcmp(order, 'stable') 

        if isSortedA 

             sortA = a; 

             indSortA = (1:numelA)'; 

        else 

            [sortA,indSortA] = sort(a); 

        end 

    else 

        if isSortedA 

            sortA = a; 

        else 

            sortA = sort(a); 

        end 

    end 

    % groupsSortA indicates the location of non-matching entries.

    if isnumeric(sortA) && (numelA > 1) 

        dSortA = diff(sortA);

        if (isnan(dSortA(1)) || isnan(dSortA(numelA-1)))

            groupsSortA = sortA(1:numelA-1) ~= sortA(2:numelA);

        else

            groupsSortA = dSortA ~= 0;

        end

    else 

        groupsSortA = sortA(1:numelA-1) ~= sortA(2:numelA); 

    end 

    if (numelA ~= 0) 

        if strcmp(order, 'last') 

            groupsSortA = [groupsSortA; true];          % Final element is always a member of unique list.

        else  % if (strcmp(order, 'sorted') || strcmp(order, 'stable')) 

            groupsSortA = [true; groupsSortA];          % First element is always a member of unique list.

        end

    else 

        groupsSortA = zeros(0,1); 

    end 

    % Extract unique elements.

    if strcmp(order, 'stable')  

        invIndSortA = indSortA;

        invIndSortA(invIndSortA) = 1:numelA;  % Find inverse permutation.

        logIndA = groupsSortA(invIndSortA);   % Create new logical by indexing into groupsSortA.

        c = a(logIndA);                       % Create unique list by indexing into unsorted a.

    else 

        c = sortA(groupsSortA);         % Create unique list by indexing into sorted list. 

    end 

    % Find indA.

    if nargout > 1 

        if strcmp(order, 'stable')  

            indA = find(logIndA);           % Find the indices of the unsorted logical.

        else 

            indA = indSortA(groupsSortA);   % Find the indices of the sorted logical. 

        end 

    end 

    % Find indC.

    if nargout == 3 

        groupsSortA = full(groupsSortA); 

        if numelA == 0 

            indC = zeros(0,1); 

        else

            switch order

                case 'last'

                    indC = cumsum([1;groupsSortA(1:end-1)]);            % Lists position, starting at 1.

                    indC(indSortA) = indC;                              % Re-reference indC to indexing of sortA.

                case 'sorted' 

                    indC = cumsum(groupsSortA);                         % Lists position, starting at 1.

                    indC(indSortA) = indC;                              % Re-reference indC to indexing of sortA.

                otherwise % 'stable'

                    [~,indSortC] = sort(c);                             % Sort C to get index.

                    lengthGroupsSortA = diff(find([groupsSortA; true]));  % Determine how many of each of the above indices there are in IC.

                    diffIndSortC = diff(indSortC);                        % Get the correct amount of each index.

                    diffIndSortC = [indSortC(1); diffIndSortC];

                    indLengthGroupsSortA = cumsum([1; lengthGroupsSortA]);

                    indLengthGroupsSortA(end) = [];

                    indCOrderedBySortA(indLengthGroupsSortA,1) = diffIndSortC;        % Since indCOrderedBySortA is not already established as a column,

                    if sum(lengthGroupsSortA) ~= length(indCOrderedBySortA);        % This is false if all the elements in A originally were unique and

                        indCOrderedBySortA(sum(lengthGroupsSortA),1) = 0;             % true if the original A had duplicates.

                    end

                    indCOrderedBySortA = cumsum(indCOrderedBySortA);

                    indC = indCOrderedBySortA(invIndSortA);                 % Reorder the list of indices to the unsorted order.

            end

        end 

    end 

    % If A is row vector, return C as row vector.

    if rowvec 

        c = c.';

    end

else    % 'rows' case

    if ~ismatrix(a)

        error(message('MATLAB:UNIQUE:ANotAMatrix'));

    end

    numRows = size(a,1);

    numCols = size(a,2);

    % Sort A and get the indices if needed.

    isSortedA = false;

    if isnumeric(a) && ~isobject(a)

       isSortedA = issorted(a,'rows'); 

    end

    if nargout > 1 || strcmp(order, 'stable') 

        if isSortedA

            sortA = a;

            indSortA = (1:numRows)';

        else

            [sortA,indSortA] = sortrows(a);

        end

    else

        if isSortedA

            sortA = a;

        else

            sortA = sortrows(a);

        end

    end

    % groupsSortA indicates the location of non-matching entries.

    groupsSortA = sortA(1:numRows-1,:) ~= sortA(2:numRows,:);

    groupsSortA = any(groupsSortA,2);

    if (numRows ~=0)

        if strcmp(order, 'last') 

            groupsSortA = [groupsSortA; true];          % Final row is always member of unique list.

        else  % if (strcmp(order, 'sorted') || strcmp(order, 'stable')) 

            groupsSortA = [true; groupsSortA];          % First row is always a member of unique list.

        end

    end

    % Extract Unique elements.

    if strcmp(order, 'stable')

        invIndSortA = indSortA;

        invIndSortA(invIndSortA) = 1:numRows;               % Find the inverse permutation of indSortA.

        logIndA = groupsSortA(invIndSortA);                 % Create new logical by indexing into groupsSortA.

        c = a(logIndA,:);                                   % Create unique list by indexing into unsorted a.

    else

        c = sortA(groupsSortA,:);         % Create unique list by indexing into sorted list.

    end

    % Find indA.

    if nargout > 1

        if strcmp(order, 'stable')

            indA = find(logIndA);           % Find the indices of the unsorted logical.

        else

            indA = indSortA(groupsSortA);   % Find the indices of the sorted logical.

        end

    end

    % Find indC.

    if nargout == 3

        groupsSortA = full(groupsSortA);

        switch order

            case 'last' 

                if (numRows == 0)

                    indC = cumsum(groupsSortA);                         % Empty A - use all of groupsSortA.

                    indC(indSortA) = indC;

                else

                    indC = cumsum([1;full(groupsSortA(1:end-1))]);      % Lists position, starting at 1.

                    indC(indSortA) = indC;                              % Re-reference indC to indexing of sortA.

                end

            case 'sorted' 

                indC = cumsum(groupsSortA);                             % Lists position, starting at 1.

                indC(indSortA) = indC;                                  % Re-reference indC to indexing of sortA.

            otherwise % 'stable'

                if numCols == 0

                    indC = ones(numRows,1);                             % For 'stable' ensure that empty A gives correct size and shape.

                elseif numRows == 0

                    indC = zeros(0,1);

                else

                    [~,indSortC] = sortrows(c);                         % Sort C to get index.

                    lengthGroupsSortA = diff(find([groupsSortA; true]));    % Determine how many of each of the above indices there are in IC.

                    diffIndSortC = diff(indSortC);

                    diffIndSortC = [indSortC(1); diffIndSortC];

                    indLengthGroupsSortA = cumsum([1; lengthGroupsSortA]);  % Get the correct amount of each index.

                    indLengthGroupsSortA(end) = [];

                    indCOrderedBySortA(indLengthGroupsSortA,1) = diffIndSortC;        % Since indCOrderedBySortA is not already established as a column,

                    if sum(lengthGroupsSortA) ~= length(indCOrderedBySortA);

                        indCOrderedBySortA(sum(lengthGroupsSortA),1) = 0;

                    end

                    indCOrderedBySortA = cumsum(indCOrderedBySortA);

                    indC = indCOrderedBySortA(invIndSortA);                 % Reorder the list of indices to the unsorted order.

                end

        end

    end

end 

end