function enUk(arr) {
let obj = {};

 
for (var i = 0; i < arr.length; i++)
{
    let enword = Object.keys(arr[i])[0];
    if(!(enword in obj))
    {
        obj[enword] = [];
      }
        obj[enword].push(arr[i][enword]);
    }
 
    return obj;

   }    

const arr = [{"table" : "стол"}, {"table" : "таблица"}, {"map" : "карта" }];
const re = enUk(arr);

 function enUk(arr){
    let obj = new Object();
    arr.forEach(pair => {
        Object.keys(pair).forEach(key => {
            if(obj[key] == undefined){
                obj[key] = [pair[key]];
            }else {
                obj[key].push(pair[key]);
            }
        })
    });
    return obj;
}

 function enUk(arr) {
    let obj = {};
    for (let item of arr) {
        for (let key in item) {
            if (obj[key] == undefined) {
                obj[key] = [item[key]];
            } else {
                obj[key].push(item[key])
            }
        }
    }
    return obj;
}

 function enUk(arr) {
   let obj = {}
   for (let i = 0; i< arr.length; i++){
      for (let prop in arr[i]){
         obj[prop]=[]
      }
   }
   for (let i = 0; i< arr.length; i++){
      for (let prop1 in arr[i]){
         obj[prop1].push(arr[i][prop1])       
      }
   } 
return obj
}

 function enUk(arr){
    let res = {};
for (let e of arr){
    for (let i in e){
    if (!res[i]){
        res[i] = [e[i]]
    }else {
        res[i].push(e[i])
    }
   }
 }
    return res
}

 function enUk(arr) {
    let vocab = {};
    for(let i = 0; i < arr.length; i++) {
        const curWords = arr[i];
        for (let word in curWords)
            if (vocab[word]) 
                vocab[word].push(curWords[word]);
            else 
                vocab[word] = [curWords[word]];
    }
    return vocab;
}

 function enUk(arr) {
    let slovnyk = {};
    for (let i = 0; i < arr.length; i++) {
        for (let j in arr[i]) {
            if (!slovnyk[j]) slovnyk[j] = [];
            slovnyk[j].push(arr[i][j]);
        }
    }
    return slovnyk;
}

 function enUk(arr){
    let dict = {};
    for (let a of arr) {
        let en = Object.keys(a)[0];
        let ru = a[en];
        if (en in dict)
            dict[en].push(ru);
        else
            dict[en] = [ru];
    }
    return dict;
}

 function enUk(arr)
{
    let result = {};
    for (let i of arr)
    {
        for (let j in i)
        {
            if (!result[j])
            {
                result[j] = [i[j]]
            }
            else 
            {
                result[j].push(i[j])
            }
        }
    }
    return result;
}

 function enUk (arr) {
let obj = {}
for (i of arr) {
for (let key in i) {
if (obj[key] == undefined) {
obj[key] = [i[key]]
}
else obj[key].push(i[key])
}

}
return obj
}

 function enUk(array){
    let object = {};

    for(let element in array) {
        
        let name = Object.getOwnPropertyNames(array[element]);
        
        if(!(name in object))
            object[name] = [];

        object[name].push(array[element][name])

    }
    return object;
}

 function enUk(arr) {
    let keys = [];
    let values = [];
    let k = 0;
    for(let i in arr){
       for(let j in arr[i]){
        keys[k] = j;
        values[k] = arr[i][j];
        k++;
       }
    }
    let obj = {};
    for(let i = 0; i < keys.length; i++){
      for(let j = 0; j < keys.length; j++){
       if(i != j && keys[i] == keys[j]){
         obj[keys[i]] = [values[i], values[j]];
         if(i > j){
        keys.splice(i, 1);
        keys.splice(j, 1);
        values.splice(i, 1);
        values.splice(j, 1);
        j = 0;
        i = 0;
         }else if(i < j){
       keys.splice(j, 1);
       keys.splice(i, 1);
       values.splice(j, 1);
       values.splice(i, 1);
       j = 0;
       i = 0;
         }
        
       }
      }
    }
    for(let i in keys){
     obj[keys[i]] = [values[i]]; 
    }
      return obj;
  }

 function enUk(arr){
    let obj={}
    for(let i in arr)   {
    keyElement = Object.keys(arr[i])[0]
    if(obj[keyElement]===undefined) {
            obj[keyElement]=[arr[i][keyElement]]
    } else {
            obj[keyElement].push(arr[i][keyElement])
    }
    }
    return obj
}

 function enUk(arr) {
   let dictionary = {}
   arr.forEach((element) => {
      for(let i in element) {
         if (dictionary[i] === undefined) {
            dictionary[i] = [element[i]];
      
         } else {
            dictionary[i].push(element[i]);
         }
      }
      
   })
   return dictionary;

}

 function enUk(arr){
    let arrobj = {}
    for(i=0;i< arr.length;i++){
        for(j in arr[i]){
            arrobj[j]=[]
        }
    }
    for(i=0;i< arr.length;i++){
        for(j in arr[i])
            arrobj[j].push(arr[i][j])
    }
    return arrobj
}

 function enUk(arr) { 
   let keys = [], obj = {}; 
   for (let i = 0; i < arr.length; i++) { 
      keys.push(Object.keys(arr[i])[0]); 
   } 
   for (let i = 0; i < keys.length; i++) { 
      if (obj[keys[i]] === undefined){ 
         obj[keys[i]] = []; 
         for (let j = 0; j < arr.length; j++) { 
            if (arr[j][keys[i]] !== undefined){ 
               obj[keys[i]].push(arr[j][keys[i]]); 
            } 
         } 
      } 
   } 
   return obj; 
}

 function enUk(arr) {
    let vocab = {};
    for(let i = 0; i < arr.length; i++) {
        const curWords = arr[i];
        for (let word in curWords)
            if (vocab[word]) 
                vocab[word].push(curWords[word]);
            else 
                vocab[word] = [curWords[word]];
    }
    return vocab;
}

 function enUk(arr){
    let obj = {};
    let mass = [];
    for(let each of arr){
        for(let i in each){
            if(mass.indexOf(i) == -1){
                obj[i] = [each[i]];
                mass.push(i);
            }else{
                obj[i].push(each[i]);
            }
            
        }
    }
    return obj;
}

 function enUk(arr) {
  let array = {};
  for (let i = 0; i < arr.length; i++) {
    let obj = arr[i];
    let wordEn = Object.keys(obj)[0];
    let wordUk = obj[wordEn];
    if (!array[wordEn]) {
      array[wordEn] = [wordUk];
    } else {
      array[wordEn].push(wordUk);
    }
  }
  return array;
}

 function enUk(arr){
    const obj = {}
    for (pair of arr){
        for (eng in pair){
            if (!obj[eng]) {obj[eng] = [pair[eng]]}
            else obj[eng].push(pair[eng])
        }
    }
    return obj
}

 function enUk(arr){
    let dict = {};
    for (let a of arr) {
        let en = Object.keys(a)[0];
        let ru = a[en];
        if (en in dict)
            dict[en].push(ru);
        else
            dict[en] = [ru];
    }
    return dict;
}

 function enUk (arr) {
    let obj = {}
    for (i of arr) {
        for (let key in i) {
            if (obj[key] == undefined) {
                obj[key] = [i[key]]
            }
            else obj[key].push(i[key])
        }
    }
    return obj
}

 function enUk(arr){
    const dictionary = {};
    
    const names = [...new Set(arr.map(key => Object.keys(key)[0]))].forEach(name => 
        dictionary[name] = [...arr.map(el => Object.keys(el)[0] === name && Object.values(el)[0])].filter(word => word));
    
    return dictionary;
}

 function enUk(arr) {
   let tr = {}
   for (i=0; i      prop = arr[i]
      for (let key in prop){
      if(tr[key] === undefined) tr[key] = []
      tr[key].push(prop[key])
      }
   }
   return tr;
}

 function enUk(arr){
    let dictionary = {};
    for (let a of arr) {
        let en = Object.keys(a)[0];
        let uk = a[en];
        if (en in dictionary)
            dictionary[en].push(uk);
        else
            dictionary[en] = [uk];
    }
    return dictionary;
}

 function enUk(arr) {
  const dictionary = {};
  for (const obj of arr) {
    const en = Object.keys(obj)[0];
    const uk = obj[en];
    if (!dictionary[en]) {
      dictionary[en] = [uk];
    }
    else {
      dictionary[en].push(uk);
    }
  }

  return dictionary;
}

 function enUk(arr) {
   let res = {};
   for (let pair of arr){
      for (let en in pair){
        if(res[en] == undefined) res[en] = [pair[en]];
        else res[en].push(pair[en])
      }
   }
   return (res);
}

 function enUk(arr) {
    let dictionary = {};
    for (let i = 0; i < arr.length; i++) {
        for (let j in arr[i]) {
            if (!dictionary[j]) dictionary[j] = [];
            dictionary[j].push(arr[i][j]);
        }
    }
    return dictionary;
}

 function enUk(arr){
    let obj = {}
    for(let el in arr){
        for(let el2 in arr[el]){
            obj[el2] = [];
        }
    }
    for(let el in arr){
        for(let el2 in arr[el]){
            obj[el2].push(arr[el][el2]);
        }
    }
    return obj
}

 function enUk(arr) {
    return arr.reduce((res, item) => {
        const [en, ua] = Object.entries(item)[0];
        res[en] ? res[en].push(ua) : res[en] = [ua]
        return res;
    }, {})
}

 function enUk(arr)
{
    let d = new Object ()
    for (let key in arr)
    {
        for (let i in arr[key])
        {
            d[i] = []
        }
    }
    for (let key in arr)
    {
        for (let i in arr[key])
        {
            d[i].push(arr[key][i])
        }
    }
    return d
}

 function enUk(arr) {
    let a = {};
    for (let x of arr) {
        for(let key in x) {
           if (!(key in a)) a[key] = [];
           a[key].push(x[key]);  
        }
    }
    return a;
}

 function enUk(arr){
    let res = {};
for (let e of arr){
    for (let i in e){
    if (!res[i]){
        res[i] = [e[i]]
    }else {
        res[i].push(e[i])
    }
   }
 }
    return res
}

 function enUk(arr) {
  const result = {};
  arr.forEach(el=>{
    for (const [key, value] of Object.entries(el)) {
      if (!result[key])
        result[key] = [];
      result[key].push(value);
    }
  });
  return result;
}

 function enUk(arr){
    let re = {}
    for (i of arr){
        for(let key in i){
            if(re[key] == undefined){
                re[key] = [i[key]]
            }
            else re[key].push(i[key])
        }
        console.log(i)
    }
    return re
}

 function enUk(arr)
{
    let dictionary = {}
    for(let i in arr)
    {
        for(let j in arr[i])
        {
            dictionary[j] = dictionary[j]
            if(dictionary[j] === undefined) dictionary[j] = []
            dictionary[j].push(arr[i][j])
        }
    }
    return dictionary
}

 function enUk(arr) {
    let obj = {}
    
    for (let i of arr) {
        [key, value] = Object.entries(i)[0];
        obj[key] !== undefined ? obj[key].push(value) : obj[key] = [value];
    }
    
    return obj;
}

 function enUk(arr){
    let result = []
    let result1=[]
    let counter = {}
    let final = {}
    for(let i of arr){
        for(let k in i){
            result1.push([...Object.keys(i),i[k]])
        }
    }
    for (let i of result1){
        if(counter[i[0]]){
            counter[i[0]]++;
        }
        else{
            counter[i[0]] = 1
        }     
    }
    for(let i in counter){
        let temp = []
        if(counter[i]>1){
            for(let k of arr){
                for(let n in k){
                    if(n == i){
                        temp.push(k[n])
                        console.log(temp)
                        final[n] = temp
                    }
                    else{
                        final[n] = [k[n]]
                    }
                }
            }
        }
    }
    return final
}

 function enUk(arr){
    let dict = {};
    for (let a of arr) {
        let en = Object.keys(a)[0];
        let ru = a[en];
        if (en in dict)
            dict[en].push(ru);
        else
            dict[en] = [ru];
    }
    return dict;
}

 function enUk(arr) {
    let dict = {};
    for (let a of arr) {
        let en = Object.keys(a)[0];
        let uk = a[en];
        if (en in dict) {
            dict[en].push(uk);
        }
        else {
            dict[en] = [uk];
        }
    }
    return dict;
}

 function enUk(arr) {
    let dictionary = {};
    for (let i = 0; i < arr.length; i++) {
        for (let j in arr[i]) {
            if (!dictionary[j]) dictionary[j] = [];
            dictionary[j].push(arr[i][j]);
        }
    }
    return dictionary;
}

 function enUk(arr) {
    let obj = {};
    for (let a of arr) {
    for (let i in a) {
    if (!obj[i]) {
        obj[i] = [a[i]]
    } else {
        obj[i].push(a[i])
   }
}
}
    return obj


}

 function enUk(arr) {
    let obj = {};
    for (let i = 0; i < arr.length; i++) {
        let key = Object.keys(arr[i]);
        if (!(key in obj)) obj[key] = new Array();
        obj[key].push(arr[i][key]);
    }
    return obj;
}

 function enUk(arr)
{
    let result_obj = new Object();
    let temp; // ключ свойства, единственного в объекте

    for(let i = 0; i < arr.length; i++)
    {
        temp = Object.keys(arr[i])[0];
        console.log(temp);
        if(!result_obj[temp]) 
            result_obj[temp] = []; // если по этому ключу undefined, добавляем массив
        result_obj[temp].push(arr[i][temp]); // по текущему ключу добавим значение св-ва из arr[i]
    }
    return result_obj;
}

 function enUk(arr) {
let obj = {};
for(let i = 0; i < arr.length; i++){
   let key = Object.keys(arr[i]);
   let ch = [arr[i][key]]
   obj[key]= ch;
   for(let j = i + 1; j < arr.length; j++){
      let keyX = Object.keys(arr[j]);
      let chX = arr[j][keyX]
      if (key[0]==keyX[0]){
         obj[key].push(chX);
         arr.splice(j, 1); 
      }
   }
}
return obj;
}

 function enUk(arr){
    let dict = {};
    for (let a of arr) {
        let en = Object.keys(a)[0];
        let ua = a[en];
        if (en in dict)
            dict[en].push(ua);
        else
            dict[en] = [ua];
    }
    return dict;
}

 function enUk(arr) {
    answ = new Object();

    for (let i = 0; i < arr.length; i++) {
        let f = arr[i];
 
        for (let key in f) {
            if (answ[key] === undefined) answ[key] = [];
            answ[key].push(f[key]);
        }
    }
    return answ;
}

 function enUk(arr) {
  let dict = {};

  for (let obj of arr) {
    let word = Object.keys(obj)[0];

   
    if (!dict[word]) {
      dict[word] = [obj[word]];
    }
    else {
      dict[word].push(obj[word]);
    }
  }

  return dict;
}

 function enUk(arr) {
    return arr.reduce((res, item) => {
        const [en, ua] = Object.entries(item)[0];
        res[en] ? res[en].push(ua) : res[en] = [ua]
        return res;
    }, {})
}

 function enUk(arr){
    let dictionary = {};
    for (let item of arr) {
        let en = Object.keys(item)[0];
        let uk = item[en];
        if (en in dictionary) {
            dictionary[en].push(uk);
        } else {
            dictionary[en] = [uk];
        }
    }
    return dictionary;
}

 function enUk(arr){ 
    let dict={}
    for(const elem of arr){
        for(let elem2 in elem){
        let argarr=dict[elem2] || []
        argarr.push(elem[elem2])
        dict[elem2]=argarr
        }
    } 
    return dict 
    }

 function enUk(arr){
    let r = {}
    for(let i of arr){
        for(let e in i){
            if(!r[e]){
                r[e] = [i[e]]
            }else{
                r[e].push(i[e])
            }
        }
    }
    return r
}

 function enUk(arr) {
  let dict={};
  for (let a of arr){
      let en=Object.keys(a)[0];
      let uk=a[en];
      if (en in dict){
          dict[en].push(uk);
      }
      else{
          dict[en]=[uk];
      }
  }
  return dict;
}

 function enUk(arr) {
    let slov = {};
    for (let a of arr) {
        let en = Object.keys(a)[0];
        let uk = a[en];
        if (en in slov) {
            slov[en].push(uk);
        }
        else {
            slov[en] = [uk];
        }
    }
    return slov;
    }

 function enUk(arr) {
    let a = {};
    for (let i = 0; i < arr.length; i++) {
        for (let j in arr[i]) {
            if (!a[j]) {
                a[j] = [];
            }
            a[j].push(arr[i][j]);
        }
    }
    return a;
}

 function enUk(arr) {
        let slov = {}

        for (let i = 0; i < arr.length; i++) {

            for (let prop in arr[i]) {
                exists = false

                for (let exProp in slov) {
                    if (prop == exProp) {
                        slov[exProp].push(arr[i][prop])
                        exists = true
                    }
                }
                if (exists == false) {
                    slov[prop] = [arr[i][prop]]
                }
            }

        }

        return slov
    }

 function enUk(arr)
{
let res = {}
for(let n in arr)
{
let name = Object.keys(arr[n])
let obj = arr[n]
if(!res[name])
res[name[0]]=[obj[name]] 
else
res[name[0]].push(obj[name])
} 
return res
}

 function enUk(arr){
    let vocab = {}
    for(let obj of arr){
        for(let value in obj){
            if(vocab[value] === undefined){
             vocab[value] = [obj[value]] 
             continue;
            }
            vocab[value].push(obj[value])
        }
    }
    return vocab;
}

 function enUk(arr){
    let new_vocab = {};
    for(let i = 0; i < arr.length; i++){
        let object = arr[i]
english = Object.keys(object);
ukr = Object.values(object)
let el = english.pop()
if(new_vocab.hasOwnProperty(el)){
let array = new_vocab[el]
array.push(ukr.pop())
}
else{
new_vocab[el] = ukr; 
}
    }
return new_vocab
}

 function enUk(arr) {
  let dict = {};
  for (let obj of arr) {
    for (let word in obj) {
      if (word in dict) {
        dict[word].push(obj[word]);
      } else {
        dict[word] = [obj[word]];
      }
    }
  }
  return dict;
}

 function enUk(arr) {
    let obj = {};
    let temp;
    let temp1;
    for(let velArr of arr){
        temp = Object.entries(velArr)[0][0];
        temp1 = Object.entries(velArr)[0][1];
        if(obj[temp] != undefined){
            obj[temp] = [...obj[temp], temp1]
        }else{
            obj[temp] = [temp1];
        }
        
    }
    return obj;
}

 function enUk(arr) {
    let m = {};
    for(let i of arr) {
        for(let k in i) {
            if(!m[k]) m[k] = [];
            m[k].push(i[k]);
        }
    }
    return m;
}

function enUk(arr) {
    let res = {};
    for(let t of arr) {
        let k = Object.keys(t)[0];
        let v = Object.values(t)[0];
        if(!(k in res))
            res[k] = [];
        res[k].push(v);
    }
    return res;
}

 function enUk(arr) {
    let obj = {};
   let v = [];

   for(let i = 0; i < arr.length; i++){
       obj[Object.keys(arr[i])] = [];
       v[i] = Object.values(arr[i])[0];  
   }
   
   for (let i = 0; i < arr.length; i++)
       obj[Object.keys(arr[i])].push(v[i]);
   
   return obj;
}

 function enUk(arr)
{
    let list = {};
    
    for(let el in arr)
    {
        let k = Object.keys(arr[el]);
        
        if(list[k] == undefined)
        {
            list[k] = [];
        }
        list[k].push(Object.values(arr[el])[0]);
    }
    return list;
}

 function enUk(arr) {
   let dictionary = {};
   arr.forEach(obj => {
      let englishWord = Object.keys(obj)[0];
      let ukrainianWord = obj[englishWord];
      if (!dictionary[englishWord]) {
         dictionary[englishWord] = [];
      }
      dictionary[englishWord].push(ukrainianWord);
   });
   return dictionary;
}

 function enUk(arr){
    let elem;
    let obj = {};
    for (elem of arr){
        for (let elemen of Object.entries(elem)){
            if(Object.hasOwn(obj, elemen[0])){
                obj[elemen[0]].push(elemen[1])
            }
            else{
                obj[elemen[0]] = [elemen[1]]
                }
    }
}
    return obj
}

 function enUk(arr) {
    
    let dictionary = {};

    
    for (let i = 0; i < arr.length; i++) {
       
        let englishWord = Object.keys(arr[i])[0];
        let ukrainianWord = arr[i][englishWord];

        
        if (!dictionary[englishWord]) {
            dictionary[englishWord] = [ukrainianWord];
        } 
        
        else {
            dictionary[englishWord].push(ukrainianWord);
        }
    }

    
    return dictionary;
}

 function enUk(arr){
let obj = {};
 
for (let i = 0; i < arr.length; i++)
{
    engWord = Object.keys(arr[i])[0];
    if(!(engWord in obj))
    {
        obj[engWord] = [];
    }
    obj[engWord].push(arr[i][engWord]);
}
 
return obj;
}

 function enUk(arr)
{
   var obj = new Object();
   for(let i = 0; i< arr.length;i++)
   {
      for(let prop in arr[i])
      {
         obj[prop] = [];
      }     
   }
   for(let i = 0; i< arr.length;i++)
   {
        for(let prop in arr[i])
        {
            obj[prop].push(arr[i][prop]);
        }
    }
   return obj;
}

 function enUk(arr){
    let res = {}
  for (let i=0; i< arr.length; i++){
    for (key in arr[i]){
      if (key in res){
        res[key].push(arr[i][key])
      } else {
        res[key] = [arr[i][key]]
      }
    }
  }
  return res
}

 function enUk(arr){
    let dict = {}
    for (let i = 0; i < arr.length; i++) {
        if (dict[Object.keys(arr[i])[0]] === undefined)
            dict[Object.keys(arr[i])[0]] = [arr[i][Object.keys(arr[i])[0]]];
        else 
            dict[Object.keys(arr[i])[0]].push(arr[i][Object.keys(arr[i])[0]])   
    }
    return dict;
}

 function enUk(arr) {
    let dictionary = {};
    for (let i = 0; i < arr.length; i++) {
        for (let j in arr[i]) {
            if (!dictionary[j]) dictionary[j] = [];
            dictionary[j].push(arr[i][j]);
        }
    }
    return dictionary;
}

 function enUk(arr) {
   let list = {};
   for(let el in arr){
     let k =Object.keys(arr[el])
      if(list[k] == undefined)
         list[k] = [];
      list[k].push(Object.values(arr[el])[0])
   }
 return list;
}

 function enUk(arr){
    let newObj = {};
    for (let i = 0; i < arr.length; i++){
        for (let key in arr[i]) {
            if (!newObj[key]) {
                newObj[key] = new Array();
            }
            newObj[key].push(arr[i][key]);
        }
    }
    return newObj;

}

 function enUk(arr) {
    let dictionary = {};
    for (let i = 0; i < arr.length; i++) {
        for (let j in arr[i]) {
            if (!dictionary[j]) dictionary[j] = [];
            dictionary[j].push(arr[i][j]);
        }
    }
    return dictionary;
}

 function enUk(arr) {
    let res = {};
    for (let e of arr) {
        for (let i in e) {
            if (!res[i]) {
                res[i] = [e[i]]
            } else {
                res[i].push(e[i])
            }
        }
    }
    return res


}