function last(str, sub) {
    let position = -1;
    for(i = 0; i < str.length; i++) {
        if(str.startsWith(sub, i)) {
            position = i;
            i += sub.length - 1;
        }
    }
    return position;
}

 function last(word, sub) {
    return word.lastIndexOf(sub);
}

 function last(r, p) {
    let j = -1; 
    for (let i = 0; i < r.length; i+=p.length) {
        j = r.indexOf(p,i);
    }
    return j;
}

 function last(string, sub) {
  let lastIndex = -1;
  let index = 0;
  while ((index = string.indexOf(sub, index)) !== -1) {
    lastIndex = index;
    index += 1;
  }
  return lastIndex;
}

 function last(s, c){
    for(let i = s.length-1; i>=0; i--){
        for(let j = c.length-1, ti = i; j>=0; j--, ti--){
            if(s[ti]!=c[j]){
                break;
            } else if(j==0){
                return ti;
            }
        }
    }
    return -1;
}

 function last(str, sub){
    let strR = str.split('').reverse().join();
    let subR = sub.split('').reverse().join();
    
    let ind = strR.indexOf(subR);
    
    if (ind == -1) return -1;
    else return str.length-ind-2;
}

 function last(str, elem){
    return str.lastIndexOf(elem);
}

 function last(str, sub) {
   let con = [];
   for(let i = 0; i < str.length; i++){
   if(str.indexOf(sub, str.length - i) !== -1){
    con.push(str.indexOf(sub, str.length - i));
   }
   }
   if(con.length == 0){
     return -1;
   }
   return con[0];
 
}

 function last(str,sub) 
{
    if ((str.split(sub).length - 1) > 1) 
    {
        return (str.lastIndexOf(11));
    } 
    else 
    {
        return -1;
    }
}

 function last(str, b) {
    let a = str.split("").reverse().join('');
    let c = b.split("").reverse().join('')
    let index = a.indexOf(c, 0)
    if (index == -1) return -1;
    return a.length - index - c.length;
}

 function last(s1, s2) {
    let i = s1.length;
    while (i >= 0) {
        let sub = s1.substring(i, i + s2.length);
        if (sub == s2) return i;
            else i--;
    }
    return -1;
}

 function last(str, sub) {
    let pos = 0;
    let r = str.indexOf(sub, pos);
    let a = r;
    while (r != -1) {
        a = r;
        pos ++;
        r = str.indexOf(sub, pos);
    }
    return a;
}

 function last(str, sub)
{
    let tmp = "";
    for (let i = str.length - 1; i > 0; i--)
    {
        tmp += str[i]
        if (tmp.length == sub.length && tmp == sub)
            return i;
    }
    return -1;
}

 function last(str, sub) {
    if (str.indexOf(sub) == -1) return -1;
    else{
        let p = 0;
        let s = 0;
        while (str.indexOf(sub) != -1 ){
            s = str.indexOf(sub);
            let q = str.slice(0, s);
            let r = str.slice(s+sub.length);
            str = q.concat(r);
            p+=sub.length;
        }
        p=p-sub.length;
        return s+p;
    }
}

 function last(str, sub)
{
    return str.lastIndexOf(sub);
}

 function last(str, sub){
    return str.lastIndexOf(sub)
}

 function last(str, sub) {
         return str.lastIndexOf(sub);
}

 function last(str,sub) {
    if ((str.split(sub).length - 1) > 1) {
        return (str.lastIndexOf(11));
    } else {
        return (-1);
    }
}

 function last(str, sub) {
    let result = -1;
    for (let i = 0; i < str.length; i++) {
        if (str.charCodeAt(i) == sub.charCodeAt(0)) {
            let is_sub = false;
            for (let j = 0; j < sub.length; j++) {
                if (str.charCodeAt(i + j) != sub.charCodeAt(j)) {
                    is_sub = false;
                    break;
                } else {
                    is_sub = true;
                }
            }
            if (is_sub) {
                result = i;
                i += (sub.length - 1);
            }
        }
    }
    return result;
}

 function last(a,b){
    return a.lastIndexOf(b)
}

 const last = (s, p) => s.lastIndexOf(p)

 function last(s, p)
{
    let count = 0;

    for( i = 0; i < s.length; i++)
    {
        if(s.indexOf(p, i) != -1)
        {
            count++;
            i = s.indexOf(p, i) + p.length - 1;
        }
        else
            break;
    }
    if(count == 0)
        return -1;
    return i - p.length;
}

 function last(s, p) 
{ 
    var count = 0; 
 
    for(var i = 0; i < s.length; i++) 
    { 
        if(s.indexOf(p, i) != -1) 
        { 
            count++; 
            i = s.indexOf(p, i) + p.length - 1; 
        } 
        else 
            break; 
    } 
    if(count == 0) 
        return -1; 
    return i - p.length; 
}

 function last(str,sub){
    let m = -1;
    for(let i = str.indexOf(sub,0); i < str.length && i != -1;){
        if(str.indexOf(sub,i) != -1){
            i = str.indexOf(sub, i + sub.length);
        }
        if( i != -1){
            m = i;
        }
    }
    return m;
}

 function last(a, b){
return a.lastIndexOf(b)
}

 function last(str,sub)
{
 return str.lastIndexOf(sub);
}

 function last(str, s) {
    let n = str.indexOf(s);
    let k = 0;
    for(let i = n; i < str.length; i++) {
      if(str.indexOf(s, i+1) !== -1)
      k = str.indexOf(s, i+1);
      else{
        k = i;
        break
      } 
    }
    return k
 }

 function last(str, sub){
    let strR = str.split('').reverse().join();
    let subR = sub.split('').reverse().join();
    let ind = strR.indexOf(subR);
    if (ind == -1) return -1;
    else return str.length-ind-2;
}

 function last(str, sub) {
    let index = str.length - 1;
    while (index > -1) {
        if (str.slice(index).indexOf(sub) !== -1) {
            return index;
        }
        
        index--
    }
    return -1
}

 function last(str, sub)
{
    if(str.includes(sub))
    {
        return str.lastIndexOf(sub)
    }    
    return -1
}

 function last(str, sub){
    return str.lastIndexOf(sub)
}

 function last(string, substring) {
    let index = -1;
    for (let i = 0; i < string.length; i += substring.length)
        if (string.substr(i, substring.length) === substring) index = i;
    return index;
}

 function last(str, sub) {
    let n;
    if(str.includes(sub)){
        return str.lastIndexOf(sub);
    } else{
        return -1;
    }
 
}

 function last(str, sub){
    return str.lastIndexOf(sub)
}

function last(s, b) {
    let p = s.split(b);
    if (p.length == 1)
        return -1;
    p.splice(p.length-1, 1);
    let l = p.length-1;
    p = p.join('');
    return p.length+l*b.length;
}

 function last(str,sub) {
    let count = str.indexOf(sub,0);
    for (let i = 0; str.indexOf(sub,i+1) !== -1;i++) {
    count = str.indexOf(sub,i+1);
    }
    return count;
}

 function last(str, sub) {
    let ind=0;
    let a=0;
    if(str.indexOf(sub,a)==-1)
        {
            return -1;
        }
    for (let i=0; i< str.length ; i++)
    {
        a = str.indexOf(sub,a);
        if(a==-1)
        {
            return ind;
        }
        ind=a;
        a=a+sub.length;
    }
    return ind;
    // let result = str.lastIndexOf(sub);
    // return result;
}

 function last(s,m){
let res = 0;
    for (let i = 0; i < s.length; i++){
       res =s.lastIndexOf(m,i)
    }
    return res
}

 function last ( str, sub ) {
    let res = 0;
    for ( let i = 0; i < str.length; i++ ) {
        res = str.lastIndexOf ( sub );
    }
    return res;
}

 function last(string, substring) {
    let index = -1;
    for (let i = 0; i < string.length; i += substring.length)
        if (string.substr(i, substring.length) === substring) index = i;
    return index;
}

 function last(str, sub) {
    let pos = -1;
    let array1 = str.split("");
    let array2 = sub.split("");
    for(let i = 0; i <= array1.length - array2.length; i++){
        if (compareArrays(array1.slice(i, i + array2.length), array2)){
            i += array2.length - 1
            pos = i - 1;
        }
    }
    return pos;
}

function compareArrays(array1, array2){
    for(let i = 0; i < array1.length; i++){
        if (array1[i] != array2[i]){
            return 0;
        }
    }
    return 1;
}

 function last(str, sub){
    return str.lastIndexOf(sub)
}

 function last(row,row2){return row.lastIndexOf(row2)||-1}

 function last(str,sub){
    if (str.lastIndexOf(sub))
        return str.lastIndexOf(sub);    
    else 
        return -1;
}

 function last(str, sub) {
 let s = str.lastIndexOf(sub)
 return s
}

 function last(str, sub) {
    let drey = 0;
   let drop = str.slice(str.length - sub.length, str.length);
   if(drop == sub){
    drey = str.length - sub.length;
     }else{drey = -1}
   return drey;
  }

 function last(str, sub){
    let y = str.lastIndexOf(sub)
    
    return y
}

 function last(a, b) {
    return a.lastIndexOf(b);
}

 function last(a,b){
    return a.lastIndexOf(b)
}

 function last(str, sub){
    for (let i = str.length; i >= -1; i--){
        if (i == str.indexOf(sub, i)){
            return i
        } else if (i == -1) {
            return (-1)
        }
    }
}

 function last(s, c){
    let cl = c.length
    for (let i = 0; i < s.length; i+= cl){
        if (s.substr(i, cl) == c) {
            return s.lastIndexOf(c)
        }
        else return -1
    }
    return sum
}

 function last(str, str2){
    return str.lastIndexOf(str2);
}

 function last(str, sub) {
    let index;
 for(let i = str.length-1; i > 0 ;i--){
    if(str.substr(i, i+sub.length) == sub){
        index = i;
        return index;
    }
 }
 return -1;
}

 const last = (string, subString) => string.lastIndexOf(subString)

 function last(str, sub) {
    let arr = [];
    for (i = 0, n = sub.split('').length; i < str.split('').length; i++) {
        v = str.split('').splice(i, n).join('');
        arr.push(v)
    }
    return (arr.lastIndexOf(sub));
}

 function last(str, sub){
    let result=0;
    for (let i=0; i< str.length; i++) {
        result=str.lastIndexOf(sub);
    }
    return result;
}

 function last(str,sub){
    return str.lastIndexOf(sub)?str.lastIndexOf(sub):-1
}

 function last(str, sub){
    return str.lastIndexOf(sub);
}

 function last(str, sub) {
    if (str.lastIndexOf(sub))
    return str.lastIndexOf(sub);
}

 function last(string, substring){
    let index = -1;
    for (let i = 0; i < string.length; i += substring.length)
        if (string.substr(i, substring.length) === substring) index = i;
    return index;
}

 function last(str, sub) {
 return str.lastIndexOf(sub);
}

 function last(str, sub) {
    let index = str.indexOf(sub);
    if (index == -1){
        return index
    }
    else{
        let count = []
        str.split(' ');
        sub.split(' ')
        for(let i = 0; i <= str.length; i++){
            if(sub.includes(str[i])){
                count.push(i)
                i += sub.length - 1;
            }
        }
        return count.pop()
    }
}

 function last(str, sub)
{
return str.lastIndexOf(sub);
}

 function last(str, sub) {
    for (let i = ((str.length-1)+1)-sub.length, t = (str.length-1)+1; i!=0; i--, t--){
        let slice = str.slice(i, t)
        if (slice==sub){
            return i
        }
    } 
    return -1
}

 function last(str, sub){
    if(str.includes(sub)){
        return str.lastIndexOf(sub)
    }
    else{
        return -1
    }
}

 function last(str, sub)
{
return str.lastIndexOf(sub)
}

 function last(str,sub)
{
    return str.lastIndexOf(sub);
}

 function last(string, subStr) {
  return string.lastIndexOf(subStr);
}

 function last(str, sub){
    let a=-1
    for(i=0;i< str.length;i++){
        if(str[i]==sub[0]){
            let b=0
            for(j=i,k=0;j< i+sub.length;j++,k++){
if(str[j]==sub[k]){
b++
}
}
            if(b==sub.length){
                a=i
i=i+sub.length-1
            }
        }
    }
    return a
}

 function last(a, b) {
    var summa = 0;
    for (var i = 0; i < a.length; i++) {
        if (a.indexOf(b,i) != - 1) {
            summa++;
            i = a.indexOf(b,i) + b.length - 1;
        }
        else {
            break;
        }
    }
    if(summa == 0) {
        return -1;
    }
            return i - b.length;
}

 function last(str, sub) {
    if(str.includes(sub))
        return str.lastIndexOf(sub);
    
    else
        return -1;
}

 function last(str, sub){
    let pos =0;
    let res = -1;
    while (true) {
        let foundPos = str.indexOf(sub, pos);
        if (foundPos == -1) break;
      
        res = foundPos;
        pos = foundPos + 1; // продовжуємо з наступної позиції 
    }
    return res;
}

 function last(a,b){
    return a.lastIndexOf(b)
}

 function last(a, b)
{
    let n = a.lastIndexOf(b);
    return n;
}

 function last(str, pos) {
    return str.lastIndexOf(pos);
}

 function last(str, smallstr)
{
let lastindex = -1;
index = 0;
    while(index>=0)
    {
        lastindex = str.indexOf(smallstr,index);
        index = str.indexOf(smallstr,index+1);
    }
    return lastindex;
}
console.log(last('0112311', '11') );

 function last(str, sub){
    return str.lastIndexOf(sub)
}

 function last(str, sub) {
    let count = -1;
    for(let i = 0; str.indexOf(sub, i) != -1; i = sub.length + str.indexOf(sub, i) ){
        count = str.indexOf(sub, i)
    }
    return count;
}

 function last(str, sub) {
    let counter = 0;
    for(var n = 0; n < str.length; n++)
        {
            if(str.indexOf(sub, n) != -1)
            {
                counter++;
                    
                n = str.indexOf(sub, n) + sub.length - 1; 
            }
        
            if(counter == 0)
            {
                return -1;
            }    
            
        
        
        
        }
        return n - sub.length;
    
 
}

 function last(str, sub) {
    let i=str.length-sub.length 
    let a=-1
    while(i){
        a=str.indexOf(sub,i)
        if(a!=-1){ 
            return a
        } 
        i-=1
    } 
    return a
}

 function last(str, sub){
    return str.lastIndexOf(sub);
}

 function last(str, pstr){
    return (str.lastIndexOf(pstr));
}

 function last(a,b){
    let c = -1;
    for(let i =0;i< a.length;i++){
        if(add(a,i,b)){c = i;}
    }
    return c;
}
function add(a,i,b){
    if(a.length-i< b.length){return false;}
    let s ='';
    for(let m =0;m< b.length;m++,i++){
        s+=a[i];
    }
    if(s==b){return true;}
    else{return false;}
}

 function last(str, sub) {
    let pos = 0
    str = str.split('').reverse().join('')
    save_pos = str.indexOf(sub)
    str = str.split('')
    str.splice(0, save_pos)
    str = str.reverse().join('')
    for (let i = 0; i<=str.length-sub.length; i++) {
        pos = str.indexOf(sub, i)
    }
    return pos
}

 function last(a, b){
return a.lastIndexOf(b)
}

 function last(str, sub){
    return str.lastIndexOf(sub);
}

 function last(a,b){
    return a.lastIndexOf(b)
}

 function last(str, substr) {
  let a
  if (str.indexOf(substr) != -1) {
    a = str.lastIndexOf(substr)
  } else {
    a = -1
  }
  return a
}

 function last(str, sub) {

    let pos;
    let strTmp = str;
    let count = 0;

    if (strTmp.indexOf(sub) >= 0) {
        pos = 0;
    } else {
        return -1;
    }

    while (strTmp.indexOf(sub) >= 0) {
        count++;
        pos = pos + strTmp.indexOf(sub);
        strTmp = strTmp.substring(strTmp.indexOf(sub)+sub.length,strTmp.length);
        pos=pos+sub.length;
    }

    pos = pos-sub.length;

    return pos;
}

 function last(str, sub) {
  return str.lastIndexOf(sub)
}

 function last(str, sub){
    let temp = str.indexOf(sub), res = -1;
    while(temp != -1)
    {
        res = temp;
        temp = str.indexOf(sub, sub.length + res)
    }
    return res
}

 function last(str, substr){
    let pos = -1;
    for (let i = 0; i < str.length; i++){
        if (str.slice(i).includes(substr)) pos = i;
    }
    return pos;
}

 function last(line, subline) {
    return line.lastIndexOf(subline);
 
}

 function last(str, sub) {
        let myStr = "";
        let count = -1;

        for (let i = 0; i < str.length; i++) {
            for (let j = 0; j < sub.length; j++) {
                myStr += str[i + j]
            }
            if (myStr == sub) {
                count = i
            }
            myStr = ""
        }

        return count
    }

 function last(str, sub) {
    for(let i=str.length-1; i>=0; i--){
        if(str.indexOf(sub, i)==i)
        return i;
    }
 return (-1);
}

 function last(str, sub){
    let m = str.lastIndexOf(sub);
    return m;
}

 function last(i,n){
    return i.lastIndexOf(n)?i.lastIndexOf(n):-1
}

 let a = '2313'
let b = '3'
function last (a,b){
   return a.lastIndexOf(b)
}
console.log(last(a,b))

 function last(string, substring) {
    let index = -1;
    for (let i = 0; i < string.length; i += substring.length)
        if (string.substr(i, substring.length) === substring) index = i;
    return index;
}

 function last(str, sub) {
    if(str.includes(sub))
        return str.lastIndexOf(sub);
    
    else
        return -1;
}

 function last(str,sub) {
    return str.lastIndexOf(sub)
}

 function last(str, sub) {
    if (!str.includes(sub))
        return -1;
    else
        return str.lastIndexOf(sub);
}

 function last(a,b){
    return a.lastIndexOf(b);
}

 function last(str,sub){
    var len = str.length
    for (var x = len-1 ; x>= 0 ; x--){
        d = str.indexOf(sub,x)
        if (d>-1){
            return d;
        }
    }return d
}

 function last(a, b) {
    let c = -1;
    for(let i = 0; i < a.length; ++i) {
        if(a.startsWith(b, i)) c = i;
    }
    return c;
}

 function last(string, substring) {
    let index = -1;
    for (let i = 0; i < string.length; i += substring.length)
        if (string.substr(i, substring.length) === substring) index = i;
    return index;
}

 const last = (str,sub) => str.lastIndexOf(sub);

 function last(str, sub){
    let res = str.lastIndexOf(sub);
    return res != 0? res:-1;
}

 function last(str, sub){
    return str.lastIndexOf(sub);
}

 function last(string, subString){
    if(string.includes(subString)){
        return string.lastIndexOf(subString);
    }else {
        return -1;
    }
}

 function last(s, p)
{
    let count = 0;
    let i = 0;

    for(i = 0; i < s.length; i++)
    {
        if(s.indexOf(p, i) != -1)
        {
            count++;
            i = s.indexOf(p, i) + p.length - 1;
        }
        else
            break;
    }
    if(count == 0)
        return -1;
    return i - p.length;
}

 function last(row,row2){return row.lastIndexOf(row2)||-1}

 function last(str, sub) {
    let s = 0;
    let a = str.split(sub).length - 1;
    if(a == 0)
        return -1;
    for(let i =0; i < a-1; i++){
        s = str.indexOf(sub, s + sub.length);
    }
    return s;
}

 function last ( str, sub ) {
    let res = 0;
    for ( let i = 0; i < str.length; i++ ) {
        res = str.lastIndexOf ( sub );
    }
    return res;
}