function [lia,locb] = ismemberR2012a(a,b,options)

% 'R2012a' flag implementation

% Error check flag

if nargin == 2 

    byrow = false; 

else

    byrow = options > 0;

end 

doBuiltinTypes = true; 

% Check that one of A and B is double if A and B are non-homogeneous. Do a

% separate check if A is a heterogeneous object and only allow a B

% that is of the same root class.

if ~(isa(a,'handle.handle') || isa(b,'handle.handle')) 

    if ~strcmpi(class(a),class(b)) 

        if isa(a,'matlab.mixin.Heterogeneous') && isa(b,'matlab.mixin.Heterogeneous') 

            rootClassA = meta.internal.findHeterogeneousRootClass(a); 

            if isempty(rootClassA) || ~isa(b,rootClassA.Name) 

                error(message('MATLAB:ISMEMBER:InvalidInputsDataType',class(a),class(b)));

            end 

            doBuiltinTypes = false; 

        elseif ~(strcmpi(class(a),'double') || strcmpi(class(b),'double'))

            error(message('MATLAB:ISMEMBER:InvalidInputsDataType',class(a),class(b)));

        end 

    end 

end 

if ~byrow 

    if ~(isa(a,'opaque') || isa(b,'opaque')) && doBuiltinTypes 

        % Builtin types

        if nargout > 1 

            [lia,locb] = ismemberBuiltinTypes(a,b);

        else 

            lia = ismemberBuiltinTypes(a,b); 

        end 

    else 

        % Handle objects

        if nargout > 1 

            [lia,locb] = ismemberClassTypes(a,b);

        else 

            lia = ismemberClassTypes(a,b); 

        end 

    end 

else    % 'rows' case

    if ~(ismatrix(a) && ismatrix(b))

        error(message('MATLAB:ISMEMBER:NotAMatrix'));

    end

    [rowsA,colsA] = size(a);

    [rowsB,colsB] = size(b);

    % Automatically pad strings with spaces

    if ischar(a) && ischar(b)

        b = [b repmat(' ',rowsB,colsA-colsB)];

        a = [a repmat(' ',rowsA,colsB-colsA)];

    elseif colsA ~= colsB

        error(message('MATLAB:ISMEMBER:AandBColnumAgree'));

    end

    % Empty check for 'rows'.

    if rowsA == 0 || rowsB == 0

        lia = false(rowsA,1);

        locb = zeros(rowsA,1);

        return

    end

    % General handling for 'rows'.

    [checkCast, cls] = needsCastingChecks(a, b);

    needLocb = (nargout > 1) || checkCast;

    % Duplicates within the sets are eliminated

    if (rowsA == 1)

        uA = repmat(a,rowsB,1);

        d = uA(1:end,:)==b(1:end,:);

        d = all(d,2);

        lia = any(d);

        if nargout > 1

            if lia

                locb = find(d, 1, 'first');

            else

                locb = 0;

            end

        end

        return;

    else

        if checkCast

            [uA,~,icA] = unique(cast(a, cls),'rows','sorted');

        else

            [uA,~,icA] = unique(a,'rows','sorted');

        end

    end

    if ~needLocb

        uB = unique(b,'rows','sorted');

    elseif checkCast && ~strcmp(cls, class(b))

        % Find rows of B that do not change when cast.

        ibC = find(all(cast(b, cls) == b, 2));

        % Find the unique rows within those rows.

        [uB,ib] = unique(b(ibC,:), 'rows','sorted');

        % Adjust the indices to account for the removed rows.

        ib = ibC(ib);

    else

        [uB,ib] = unique(b, 'rows','sorted');

    end

    % Sort the unique elements of A and B, duplicate entries are adjacent

    [sortuAuB,IndSortuAuB] = sortrows([uA;uB]);

    % Find matching entries

    d = sortuAuB(1:end-1,:)==sortuAuB(2:end,:);     % d indicates matching entries

    d = all(d,2);                                   % Finds the index of matching entries

    ndx1 = IndSortuAuB(d);                          % NDX1 are locations of repeats in C

    if ~needLocb

        lia = ismemberBuiltinTypes(icA,ndx1);           % Find repeats among original list

    else

        szuA = size(uA,1);

        [lia,locb] = ismemberBuiltinTypes(icA,ndx1);    % Find locb by using given indices

        d = find(d);

        newd = d(locb(lia));                    % NEWD is D for non-unique A

        where = ib(IndSortuAuB(newd+1)-szuA);   % Index values of uB through UNIQUE

        locb(lia) = where;                      % Return first or last occurrence of A within B

    end

    if checkCast

        % Post-processing step: if we matched anything in a to b only

        % because of casting during the concatenation, we need to fix it.

        if ~strcmp(cls, class(a))

            % a may have lost precision in the concatenation.

            % Find all rows that have an entry that changed in the cast.

            rmA = any(cast(a, cls) ~= a, 2);

            % Remove these rows from elibility.

            lia(rmA) = false;

            locb(rmA) = 0;

        end

    end

end 

end