function fd(words)
{
let states = {}
for(let n of words)
{
if (!states[n])
states[n]=0
states[n]+=1
}
return states
}

 function fd(words){
    let count = 0;
    let a = {};
    for(let i in words)
    {
        for(let a in words)
        {
            if(words[i] === words[a])
                count++;
        }
        a[words[i]] = count;
        count = 0;
    }
    return a;
}

 function fd(lst) {
  let freqDict = {};

  for (let word of lst) {
    if (!freqDict[word]) {
      freqDict[word] = 1;
    }
    else {
      freqDict[word]++;
    }
  }

  return freqDict;
}

 function fd(words){
   let lst = {};
   for (i=0; i      if (lst[words[i]] === undefined){
      lst[`${words[i]}`] = 0
      }
      if (`${words[i]}` in lst) {lst[words[i]]++}
   }
   return lst;
}

 function fd(words){
    let result = {}
    for (let i of words){
        if (result[i]){
            result[i]++
        }
        else{
            result[i] = 1
        }
    }
    return result
}

 function fd(words){
    let d = {};
    for (let i of words){
        if (!d[i]) d[i] = 0;
        d[i] += 1;
    }
    return d;
}

 function fd(lst) {
    let obj = {};
    for (let i = 0; i < lst.length; i++) {
      let word = lst[i];
      if (obj[word]) {
        obj[word]++;
      } else {
        obj[word] = 1;
      }
    }
  return obj;  
}

 function fd(words){
    let vocab = {};
    for(let i = 0; i < words.length; i++)
        if (vocab[words[i]]) vocab[words[i]] = vocab[words[i]] + 1;
        else vocab[words[i]] = 1;
    return vocab;
}

 function fd(words){
     let obj = {};
     let count = 0;
    for(let i = 0;i< words.length;i++){
        obj[words[i]] = 0;
    }
     for(let key in obj){
         for(let i = 0;i < words.length;i++){
             if(key == words[i])
                 obj[key]+=1
         }
     }
     return obj
}

 function fd(words){
    let obj = {};
    for(i in words){
        if(!obj[words[i]]){
            obj[words[i]]=1;
        } else {
            obj[words[i]]++;
        }
    }
    return obj;
}

 function fd(words){
    var obj = {};
    count = 0;
    for (var i = 0;i< words.length;i ++){
        for (var j = 0;j< words.length;j++){
            if (words[i] == words[j]){count ++;}
        }
        obj[words[i]] = count;
        count = 0;
    }
    return obj;
}

 function fd(words){
let d = {};
for (let i of words){
    if (!d[i])d[i]=0;
    d[i]+=1;
}
return d;
}

 function fd(lst){
let obj = {}
lst.sort()
for(let i = 0; i< lst.length; i++){
    if(lst[i]!==lst[i-1]){
        obj[lst[i]]=1
    }else obj[lst[i]]++
}
    return obj
}

 function fd(words){
    var dictionary = {};
    count = 0;
    for (var i = 0;i< words.length;i ++){
        for (var j = 0;j< words.length;j++){
            if (words[i] == words[j]){count ++;}
        }
        dictionary[words[i]] = count;
        count = 0;
    }
    return dictionary;
}

 function fd(words){
    let obj = {};
    for (let i of words){
        if (obj[i] === undefined){
            obj[i] = 1;
        }
        else obj[i]++;
    }
    return obj;
}

 function fd(words){
    let states ={};
    let arr = [...words];
    //let words = [];
    //let e = [...words]
  ///  states= e;
  //  words.push(states);
        for (let el of arr) {
            states[el] === undefined ? states[el] = 1 : states[el]++;
        }
     return states;
}

 function fd(lst) {
    let slov = {};
    for (let i = 0; i < lst.length; i++)
        slov[lst[i]] = 0;
    for (let i = 0; i < lst.length; i++) 
        slov[lst[i]]++;
    return slov;
}

 function fd(words){
    let slovnyk = {};
    let words1 = [...words];
    console.log(words1);
    for(let each of words){
        let counter = 0;
        while(words1.indexOf(each) != -1){
            words1.splice(words1.indexOf(each),1)
            counter++;
            slovnyk[each] = counter;
        }
        
    }
    return slovnyk;
}

 function fd(words){
    let obj = {}
    for(let el in words){
        obj[words[el]] = obj[words[el]] == undefined ? 1 : obj[words[el]] +1
    }
    return obj
}

 function fd(words)
{
    let obj = {};
    let el;
    
    for (let i = 0; i < words.length; i++) 
    {
        el = words[i];
        let count = 0;
        if (obj[el] === undefined) 
        {
            for (let j = 0; j < words.length; j++) 
            {
                if (el === words[j]) 
                    count++;
            }
            obj[el] = count;
        }
    }
    return obj;
}

 function fd(words){
    let vocab = new Object()
    for(let i = 0; i < words.length; i++){
        let word = words[i]
        if(vocab[word] != undefined){
            vocab[word] ++
        }
        else{
            vocab[word]=1
        }
    }
    return vocab
}

 function fd(words)
{
    var obj = new Object();
    for(let i = 0;i< words.length;i++)
    {
        obj[words[i]] = 0;
    }
    for(let i = 0;i< words.length;i++)
    {
        obj[words[i]]++;
    }
    return obj;
    
}

 function fd(words) {
    answ = new Object();
    for (let i = 0; i < words.length; i++) {
        if (words[i] in answ) answ[words[i]]++;
        else answ[words[i]] = 1;
    }
    return answ;
}

 function fd(words){
    let dict={} 
    for(const elem of words){
        dict[elem]=(dict[elem] || 0) + 1
    } 
    return dict
}

 function fd(words){
    let summa=0;
    let a={};
    for(let i=0;i< words.length;i++){
        for(let j=0;j< words.length;j++){
            if(words[i]==words[j])
            summa++;
        }
    a[words[i]]=summa;
    summa=0;
    }
    return a;
}

 function fd(words){
    dict = {}
    for(i of words){
        if(dict[i] == undefined){
            dict[i] = 1
        }else dict[i] = dict[i]+1
    }
    return dict
}

 function fd(words) {
    return words.reduce((result, item) => {
        result[item] = words.filter(a => a == item).length;
        return result;
    }, {})
}

 function fd(words){
  let dictionary={};
  count=0;
  for (let i=0; i< words.length; i++){
      for (let j=0; j< words.length; j++){
          if (words[i]==words[j]){
            count++;
          }
      }
      dictionary[words[i]]=count;
      count=0;
  }
  return dictionary;
}

 function fd(words){
     let obj={}
    let elm= null
    
    for(let i=0; i< words.length ; i++){
        elm=words[i]
        if(obj[elm] === undefined){
        let znach=0
        for(let j=0; j< words.length; j++){
            if(elm===words[j]) znach ++
        }
        obj[elm]=znach
    }
    }
    return obj
}

 function fd(words)
{
  let slownyk = {};
  if (words[0] != undefined) 
  {
    slownyk[words[0]] = words.filter(item => item === words[0]).length;
  } 
  
  if (words[1] != undefined) 
  {
    slownyk[words[1]] = words.filter(item => item === words[1]).length;
  } 
  
  if (words[2] != undefined) 
  {
    slownyk[words[2]] = words.filter(item => item === words[2]).length;
  } 
  
  if (words[3] != undefined) 
  {
    slownyk[words[3]] = words.filter(item => item === words[3]).length;
  } 
  
  if (words[4] != undefined) 
  {
    slownyk[words[4]] = words.filter(item => item === words[4]).length;
  } 
  
  if (words[5] != undefined) 
  {
    slownyk[words[5]] = words.filter(item => item === words[5]).length;
  } 
  
  if (words[6] != undefined) 
  {
    slownyk[words[6]] = words.filter(item => item === words[6]).length;
  }
  return(slownyk);
}

 function fd(words){
    let dictionary = {};
    count = 0;
    for ( i = 0;i< words.length;i ++){
        for (j = 0;j< words.length;j++){
            if (words[i] == words[j]){count ++;}
        }
        dictionary[words[i]] = count;
        count = 0;
    }
    return dictionary;
}

 function fd(words){
    let dict = {};
    words.forEach(function (x) { dict[x] = (dict[x] || 0) + 1; });
    return dict;
}

 function fd(words){
    let res = {};
    for (let prop in words){
        if (res[words[prop]]>=1) res[words[prop]]++;
        else res[words[prop]]=1;
    }
    return (res);
}

 function fd(a){
    obj = {}
    for (var x of a){
    obj[x]=0
}
    for (var x of a){
    if (x in obj){
        obj[x]=obj[x]+1
    } 
    }
    return obj
}

 function fd(lst){
    let newlst = {};
    for (let i = 0; i < lst.length; i++){
        let language = lst[i];
        
        newlst[language] = newlst[language] ? newlst[language]+1 : 1;
    }
    return newlst;
}

 function fd(lst){
 const obj = {};
 let n = 1;
 for (let i = 0; i < lst.length; i++){
    obj[lst[i]]=n;
    for(let j = i + 1; j < (lst.length); j++){
        if(lst[i]==lst[j]){
            lst.splice(j, 1);
obj[lst[i]]=obj[lst[i]] + 1
        }
    }
 }
 return obj;
}

 function fd(words) {
    let obj = {};
    for (let x of words) {
        if (x in obj) obj[x]++;
        else obj[x] = 1;
    }
    return obj;
}

 function fd(words){
    let vocab = {}
    for(let value of words){
        if(vocab[value] === undefined){ 
            vocab[value] = 1
            continue;
        }
        vocab[value] += 1
    }
    return vocab;
}

 function fd(words)
{
    obj = {};
    let counter = 1;
    
    for(let i = 0; i < words.length; i++)
    {
        for(let j = i + 1; j < words.length; j++)
        {
            if(words[i] == words[j])
            {
                counter++;
                words.splice(j, 1);
                j--;
            }
        }
        obj[words[i]] = counter;
        counter = 1;
    }
    return obj;
}

 function fd(lst)
{
    let dictionary = {}
    for(let i in lst)
    {
        dictionary[lst[i]] = 0
    }
    for(let i in lst )
    {
        dictionary[lst[i]]++
    }
    return dictionary
}

 function fd (words) {
    let dictionary = {};
    let counter = 0;
    for (let i = 0; i < words.length; i++) {
        for (let j = 0; j < words.length; j++) {
            if (words[i] === words[j]) {
            counter++;
            }
        }
        dictionary[words[i]] = counter;
        counter = 0;
    }
    return dictionary;
}

 function fd(words){
    let obj = {};
    words.sort();
    for(let i = 0; i < words.length; i++){
        obj[words[i]] = 1;
        if(words[i] == words[i + 1]){
            for(let j = i; j < words.length +1; j++){ 
                if(words[i] == words[i + 1]){
                  obj[words[i]] ++;
                  i++;
                }
            }
        }
    }
    return obj;
}

 function fd(words){
    let r = {}
    for(let e of words){
        if(!r[e]){
            r[e] = 1
        }else{
            r[e]++
        }
    }
    return r
}

 function fd(words){
    let obj ={}
    for(let i=0;i< words.length;i++){
       if(words[i] in obj == false){
         obj[`${words[i]}`] = words.filter(x => x==words[i]).length
             
       }
    }
    return obj
}

 function fd(lst){
    let obj = {};
    for (let i of lst){
        if (!obj[i]) obj[i] = 0;
        obj[i] += 1;
    }
    return obj;
}

 function fd(lst){
    let item;
    let dict = {};
    for (item of lst){
        if(dict[item] ==1){
            dict[item]+=1
        }
        else{
            dict[item] = 1
        }
    }
    return dict
}

 function fd(words) {   
    let obj = words.reduce((cnt, cur) => (cnt[cur] = cnt[cur] + 1 || 1, cnt), {});
    return obj;
}
//

 function fd(words) {
    let m = { };
    for(let i of words) {
        if(!m[i]) m[i] = 0;
        m[i] += 1;
    }
    return m;
}

 function fd(words){
    let vocab = {};
    for(let i = 0; i < words.length; i++)
        if (vocab[words[i]]) vocab[words[i]] = vocab[words[i]] + 1;
        else vocab[words[i]] = 1;
    return vocab;
}

 function fd(words)
{
    let counter = 0;
    let dictionary = {};
    for(let i = 0; i < words.length; i++)
        {
            counter = 0;
            for (let r = 0; r < words.length; r++)
                {
                    if (words[i] == words[r])
                        counter++;
                    
                }
                dictionary[words[i]] = counter;
        }
    return dictionary;
}

 function fd(words){
    var obj = {};
    let flag = false;
    obj[words[0].toString()] = 0;
    for(let elem of words){
        for(let type in obj){
            if(elem.toString() == type.toString()){
                flag = true;
            }
        }
        if(flag){
            obj[elem.toString()] = obj[elem.toString()] + 1;
        }
        else{
            obj[elem.toString()] = 1;
        }
        flag = false;
    }

    return obj;
}

 function fd(words){
    let answ={}
    for (let i=0; i< words.length; i++) {
        if (!answ.hasOwnProperty(words[i])) {answ[words[i]]=1} else {answ[words[i]]+=1}
    }
    return answ
}

 function fd ( words ) {
    let dict = {};
    let count = 0;
    for ( let i = 0; i < words.length; i++ ) {
        for ( let k = 0; k < words.length; k++ ) {
            if ( words [ i ] == words [ k ]) {
                count ++
            }
        }
        dict [ words [ i ] ] = count;
        count = 0;
    }
    return dict;
}

 function fd(words){
    let wordsObject = {};
    for(word of words) {
        let temp = wordsObject[word];
        if(temp === undefined) {
            temp = 0;
        }
        temp++;
        wordsObject[word] = temp;
    }
    return wordsObject
}

 function fd(words){
    dict = {}
    for (let el of words){
        if (dict[el] === undefined) dict[el] = 0
        dict[el]++
    }
    return dict
}

 function fd(words)
{
    let obj = new Object();
    for(let i = 0; i < words.length; i++)
        obj[words[i]] = itemCount(words, words[i]);
    return obj;
}

function itemCount(arr, it)
{
    let res = 0;
    for(let i = 0; i < arr.length; i++)
        if(arr[i] == it) res++;
    return res;
}

 function fd(words){
  let temp = 0;
  let obj = {};
  for(let num1 of words ){
    temp = 0;
    for(let num2 of words ){
      if(num1 == num2) temp++;
    }
    obj[num1] = temp;
}
return obj;
}

 function fd(words) {
        let slov = {}

        for (let i = 0; i < words.length; i++) {
            exists = false

            for (let prop in slov) {
                if (words[i] == prop) {
                    slov[prop]++
                    exists = true
                }
            }
            if (exists == false) {
                slov[words[i]] = 1
            }
        }
        return slov
    }

 function fd(words){
    let dictionary = {};
    words.forEach((element) => {
        if (dictionary[String(element)] === undefined) {
            dictionary[String(element)] = 1;
        } else dictionary[String(element)] ++
        
    })
    return dictionary;
 
}

 function fd(words){
    words.sort();
    
    let dictionary = {};
    while (words.length != 0){
        dictionary[words[0]] = words.lastIndexOf(words[0]) + 1;
        words.splice(0, words.lastIndexOf(words[0]) + 1);
    }
    
    return dictionary;
}

 function fd(words){
    let d = {};
    for (let i of words){
        if (!d[i]) d[i] = 0;
        d[i] += 1;
    }
    return d;
}

 function fd(words) {
    let count = {};
    
    for (let w of words) count[w] !== undefined ? count[w]++ : count[w] = 1;
    
    return count;
}

 function fd(words){
    let obj = new Object();
    
    for(let i = 0; i < words.length; i++) {
        obj[words[i]] = 0;
    }
        
    for(let i = 0; i < words.length; i++){
        if (obj[words[i]] != undefined){
            obj[words[i]] += 1;
        }
    }
    
    return obj;
}

 function fd(words){
    let a = {};
    words.forEach((element) => {
        if (a[String(element)] === undefined) {
            a[String(element)] = 1;
        }
        else {
            a[String(element)]++;
        }
    })
    return a;
}

 function fd(words){
  let slownyk = {};
  if (words[0] != undefined) {
    slownyk[words[0]] = words.filter(item => item === words[0]).length;
  } if (words[1] != undefined) {
    slownyk[words[1]] = words.filter(item => item === words[1]).length;
  } if (words[2] != undefined) {
    slownyk[words[2]] = words.filter(item => item === words[2]).length;
  } if (words[3] != undefined) {
    slownyk[words[3]] = words.filter(item => item === words[3]).length;
  } if (words[4] != undefined) {
    slownyk[words[4]] = words.filter(item => item === words[4]).length;
  } if (words[5] != undefined) {
    slownyk[words[5]] = words.filter(item => item === words[5]).length;
  } if (words[6] != undefined) {
    slownyk[words[6]] = words.filter(item => item === words[6]).length;
  }
  return(slownyk);
}

 function fd(words){
    let d = {};
    for (let i of words){
        if (!d[i]) d[i] = 0;
        d[i] += 1;
    }
    return d;
}

 function fd(lst) {
    let dict = {};
    for (let i = 0; i < lst.length; i++)
        dict[lst[i]] = 0;
    for (let i = 0; i < lst.length; i++) 
        dict[lst[i]]++;
    return dict;
}

 function fd(words){
    let result = {}
    for (let i of words){
        if (result[i]){
            result[i]++
        }
        else{
            result[i]=1
        }
    }
    return result
}

 function fd(words){
    const result = {};
    words.forEach(el=>result[el]= (result[el] || 0)+1);
    return result;
}

 function fd(words){
    let list = {};

    for (let i in words) {
        if(list[words[i]] === undefined)
            list[words[i]] = 1;
        else
            list[words[i]]++;
    }
    return list;
}

 function fd(words){
    let res = {};
    for(let i = 0; i < words.length; i++){
        res[words[i]] = (res[words[i]]||0) + 1;
    }
    return res;
}

 function fd(words){
    let dictionary = {};
    count = 0;
    for ( i = 0;i< words.length;i ++){
        for (j = 0;j< words.length;j++){
            if (words[i] == words[j]){count ++;}
        }
        dictionary[words[i]] = count;
        count = 0;
    }
    return dictionary;
}

 function fd(words){
    let d = {};
    for (let i of words){
        if (!d[i]) d[i] = 0;
        d[i] += 1;
    }
    return d;
}

 function fd(words){
    let obj = {};
    for(i in words){
        if(!obj[words[i]]){
            obj[words[i]]=1;
        } else {
            obj[words[i]]++;
        }
    }
    return obj;
}

function fd(words) {
    let s = {};
    for(word of words) {
        s[word] = (s[word] || 0) + 1;
    }
    return s;
}

 function fd(lst) {
    let slov = {};
    for (let i = 0; i < lst.length; i++)
        slov[lst[i]] = 0;
    for (let i = 0; i < lst.length; i++) 
        slov[lst[i]]++;
    return slov;
}

 function fd(lst) {
  let dict = {};
  for (let word of lst) {
    if (word in dict) {
      dict[word]++;
    } else {
      dict[word] = 1;
    }
  }
  return dict;
}

 function fd(words) {
    let obj = {};
    for (let i = 0; i < words.length; i++) {
        let a = words[i];
        count = 0;
        for (let j = 0; j < words.length; j++) {
            if (a == words[j]) count++;
        }
        obj[a] = count;
    }
    return obj;
}

 function fd(words){
         let dictionary = {};
        words.forEach((element) => {
            if (dictionary[String(element)] === undefined){
                dictionary[String(element)] = 1;
            } else dictionary[String(element)]++;
        })
        return dictionary;
    }

 function fd(words) { 
    let obj = {};
    for (let elem of words) {
        if (obj[elem] === undefined) {
            obj[elem] = 1;
        } else {
            obj[elem]++;
        }
    }
    return obj;
}

 function fd(words){
  let names = {};
  words.forEach(item => {
    names[item] = (names[item] || 0) + 1;
  });
  return names;
}

 function fd(lst){
    let obj = new Object()
    for (let i = 0; i< lst.length; i++){
        if (obj[lst[i]] != undefined){
            obj[lst[i]] += 1
        }
        else{
            obj[lst[i]] = 1
        }      
    }
return obj
}

 function fd(words){
    let r = [words[0]]
    let d = {}
    for(i=0;i< words.length;i++){
        if(r.indexOf(words[i])==-1){
            r.push(words[i])
        }
    }
    for(i=0;i< r.length;i++){
        d[r[i]]=0
        for(j=0;j< words.length;j++){
            if(words[j]==r[i]){
                d[r[i]]++
            }
        }
    }
    return d
}

 function fd(words){
    let wordsBox = new Map();
    words.forEach(word =>{
        if(!wordsBox.has(word)){
            wordsBox.set(word, 1);
        }else{
            wordsBox.set(word, wordsBox.get(word) + 1);
        }
    });
    var obj = new Object();
    for (let key of wordsBox.keys()) {
        obj[key] = wordsBox.get(key);
    }
    return obj;
}

 function fd(words)
{
    let d = new Object ()
    for (i in words)
    {
        if(d[words[i]]>=1)
        {
            d[words[i]] ++
        }
        else
        {
            d[words[i]] = 1
        }
    }
    return d
}

 function fd(words){
    let dictionary = {};
    let frequency = 0;

    for(i in words){
        for(j in words){
            if(words[i] == words[j]){
                frequency++;
            }
        }
        dictionary[words[i]] = frequency;
        frequency = 0;
    }

    return dictionary;
}

 function fd(words){
  const result = {};
  words.forEach(el=> result[el] = (result[el] || 0) + 1);
  return result;
}

 function fd(lst) {
 
  if (!Array.isArray(lst) || lst.length == 0) {
    return {};
  }


  let dict = {};
  for (let i = 0; i < lst.length; i++) {
    if (dict[lst[i]]) {
      dict[lst[i]]++;
    } else {
      dict[lst[i]] = 1;
    }
  }

  return dict;
}