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

% 'R2012a' flag implementation

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

if nargin == 1 

    order = 'sorted';

else 

    if options(1) > 0 

        warning(message('MATLAB:UNIQUE:RowsFlagIgnored'));     % 'rows' flag ignored for cellstrs.

    end 

    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 

% check if input is an array with each element a single row text array.

if any(cellfun('size',a(:),1)>1) 

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

end 

% Determine if A is a row vector and the number of elements of A.

rowvec = isrow(a); 

numelA = numel(a); 

a = a(:); 

% Sort A and get indices.

[sortA,indSortA] = sort(a); 

% groupsSortA indicates the location of non-matching entries.

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

groupsSortA = groupsSortA(:); 

if ~isempty(a) 

    if strcmp(order, 'last')  

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

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

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

    end 

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 

    if isempty(a)

        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);

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

                end

                indCOrderedBySortA = cumsum(indCOrderedBySortA);

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

        end

    end

end 

if rowvec 

    c = c.';

end 

end