Bring out the inner llama of a sentence Your objective is to take input like

Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good.


and create an array of the indexes of the string where the letters that make up the word "Llama" appear (one of each in order).  For example, let me show the letters pointed at with carets to show the indexes:

Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good.
                                            ^                      ^        ^                            ^        ^


So the array would look like:

[44, 67, 76, 105, 114]


(If your application uses a indexing that's not 0-based, the numbers will look different.  That's fine.)

If the text has no llama, then the array should be empty, nil, null, or undefined.

Any code language is accepted.  This is a code-golf contest, so the least characters win!
Perl, 52 bytes

The solution is provided as function that takes the string as argument and returns a list of positions.


One-based positions, case-sensitive search, without newlines: 52 bytes

 sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/;@+[1..$#+]}


The case-sensitive search returns an empty array in the example of the question, because after matching the first three letters the lowercase letter m is missing in the input text.
Support of newlines: + 1 byte = 53 bytes

sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/s;@+[1..$#+]}


The text can now span several lines.
Case-insensitive search: + 1 byte = 54 bytes

 sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/si;@+[1..$#+]}


Now the example in the question reports a list of index positions,
they are one-based numbers:

[45 68 77 106 115]

Zero-based positions: + 9 bytes = 63 bytes

 sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/si;map{$_-1}@+[1..$#+]}


Result for the example in the question:

[44 67 76 105 114]



Ungolfed:

The latter variant includes more or less the other variants.

sub l {
    # pop() gets the last argument 
    pop() =~ /(l).*?(l).*?(a).*?(m).*?(a)/si;
    # the letters inbetween are matched against ".*?",
    # the non-greedy variant of ".*". Thus ".*?"
    # matches only as few as possible characters.
    # The modifier /i controls the case-sensitivity
    # and means ignore case. Without the case matters.
    # Modifier /s treats the string as single line,
    # even if it contains newlines.
    map { $_-1 }   # subtract 1 for zero-based positions
        @+[1..$#+]
    # Array @+ contains the end-positions of the last
    # submatches, and of the whole match in the first position.
    # Therefore the first value is sliced away.
    # @+ is available since Perl 5.6.
}

# test
my @result = l(&lt;&lt;"END_STR");
Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good.
END_STR
print "[@result]\n";