src/game/ChatHandler.cpp

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Common.h"
  20 #include "Log.h"
  21 #include "WorldPacket.h"
  22 #include "WorldSession.h"
  23 #include "World.h"
  24 #include "Opcodes.h"
  25 #include "ObjectMgr.h"
  26 #include "Chat.h"
  27 #include "Database/DatabaseEnv.h"
  28 #include "ChannelMgr.h"
  29 #include "Group.h"
  30 #include "Guild.h"
  31 #include "ObjectAccessor.h"
  32 #include "ScriptCalls.h"
  33 #include "Player.h"
  34 #include "SpellAuras.h"
  35 #include "Language.h"
  36 #include "Util.h"
  37 #include "GridNotifiersImpl.h"
  38 #include "CellImpl.h"
  39
  40 void WorldSession::HandleMessagechatOpcode( WorldPacket & recv_data )
  41 {
  42     CHECK_PACKET_SIZE(recv_data,4+4+1);
  43
  44     uint32 type;
  45     uint32 lang;
  46
  47     recv_data >> type;
  48     recv_data >> lang;
  49
  50     if(type >= MAX_CHAT_MSG_TYPE)
  51     {
  52         sLog.outError("CHAT: Wrong message type received: %u", type);
  53         return;
  54     }
  55
  56     //sLog.outDebug("CHAT: packet received. type %u, lang %u", type, lang );
  57
  58     // prevent talking at unknown language (cheating)
  59     LanguageDesc const* langDesc = GetLanguageDescByID(lang);
  60     if(!langDesc)
  61     {
  62         SendNotification(LANG_UNKNOWN_LANGUAGE);
  63         return;
  64     }
  65     if(langDesc->skill_id != 0 && !_player->HasSkill(langDesc->skill_id))
  66     {
  67         // also check SPELL_AURA_COMPREHEND_LANGUAGE (client offers option to speak in that language)
  68         Unit::AuraList const& langAuras = _player->GetAurasByType(SPELL_AURA_COMPREHEND_LANGUAGE);
  69         bool foundAura = false;
  70         for(Unit::AuraList::const_iterator i = langAuras.begin();i != langAuras.end(); ++i)
  71         {
  72             if((*i)->GetModifier()->m_miscvalue == int32(lang))
  73             {
  74                 foundAura = true;
  75                 break;
  76             }
  77         }
  78         if(!foundAura)
  79         {
  80             SendNotification(LANG_NOT_LEARNED_LANGUAGE);
  81             return;
  82         }
  83     }
  84
  85     if(lang == LANG_ADDON)
  86     {
  87         // Disabled addon channel?
  88         if(!sWorld.getConfig(CONFIG_ADDON_CHANNEL))
  89             return;
  90     }
  91     // LANG_ADDON should not be changed nor be affected by flood control
  92     else
  93     {
  94         // send in universal language if player in .gmon mode (ignore spell effects)
  95         if (_player->isGameMaster())
  96             lang = LANG_UNIVERSAL;
  97         else
  98         {
  99             // send in universal language in two side iteration allowed mode
 100             if (sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT))
 101                 lang = LANG_UNIVERSAL;
 102             else
 103             {
 104                 switch(type)
 105                 {
 106                     case CHAT_MSG_PARTY:
 107                     case CHAT_MSG_RAID:
 108                     case CHAT_MSG_RAID_LEADER:
 109                     case CHAT_MSG_RAID_WARNING:
 110                         // allow two side chat at group channel if two side group allowed
 111                         if(sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP))
 112                             lang = LANG_UNIVERSAL;
 113                         break;
 114                     case CHAT_MSG_GUILD:
 115                     case CHAT_MSG_OFFICER:
 116                         // allow two side chat at guild channel if two side guild allowed
 117                         if(sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD))
 118                             lang = LANG_UNIVERSAL;
 119                         break;
 120                 }
 121             }
 122
 123             // but overwrite it by SPELL_AURA_MOD_LANGUAGE auras (only single case used)
 124             Unit::AuraList const& ModLangAuras = _player->GetAurasByType(SPELL_AURA_MOD_LANGUAGE);
 125             if(!ModLangAuras.empty())
 126                 lang = ModLangAuras.front()->GetModifier()->m_miscvalue;
 127         }
 128
 129         if (!_player->CanSpeak())
 130         {
 131             std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
 132             SendNotification(GetMangosString(LANG_WAIT_BEFORE_SPEAKING),timeStr.c_str());
 133             return;
 134         }
 135
 136         if (type != CHAT_MSG_AFK && type != CHAT_MSG_DND)
 137             GetPlayer()->UpdateSpeakTime();
 138     }
 139
 140     switch(type)
 141     {
 142         case CHAT_MSG_SAY:
 143         case CHAT_MSG_EMOTE:
 144         case CHAT_MSG_YELL:
 145         {
 146             std::string msg = "";
 147             recv_data >> msg;
 148
 149             if(msg.empty())
 150                 break;
 151
 152             if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
 153                 break;
 154
 155             // strip invisible characters for non-addon messages
 156             if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
 157                 stripLineInvisibleChars(msg);
 158
 159             if(msg.empty())
 160                 break;
 161
 162             if(type == CHAT_MSG_SAY)
 163                 GetPlayer()->Say(msg, lang);
 164             else if(type == CHAT_MSG_EMOTE)
 165                 GetPlayer()->TextEmote(msg);
 166             else if(type == CHAT_MSG_YELL)
 167                 GetPlayer()->Yell(msg, lang);
 168         } break;
 169
 170         case CHAT_MSG_WHISPER:
 171         {
 172             std::string to, msg;
 173             recv_data >> to;
 174             CHECK_PACKET_SIZE(recv_data,4+4+(to.size()+1)+1);
 175             recv_data >> msg;
 176
 177             // strip invisible characters for non-addon messages
 178             if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
 179                 stripLineInvisibleChars(msg);
 180
 181             if(msg.empty())
 182                 break;
 183
 184             if(!normalizePlayerName(to))
 185             {
 186                 WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
 187                 data<<to;
 188                 SendPacket(&data);
 189                 break;
 190             }
 191
 192             Player *player = objmgr.GetPlayer(to.c_str());
 193             uint32 tSecurity = GetSecurity();
 194             uint32 pSecurity = player ? player->GetSession()->GetSecurity() : SEC_PLAYER;
 195             if (!player || (tSecurity == SEC_PLAYER && pSecurity > SEC_PLAYER && !player->isAcceptWhispers()))
 196             {
 197                 WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
 198                 data<<to;
 199                 SendPacket(&data);
 200                 return;
 201             }
 202
 203             if (!sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT) && tSecurity == SEC_PLAYER && pSecurity == SEC_PLAYER )
 204             {
 205                 uint32 sidea = GetPlayer()->GetTeam();
 206                 uint32 sideb = player->GetTeam();
 207                 if( sidea != sideb )
 208                 {
 209                     WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
 210                     data<<to;
 211                     SendPacket(&data);
 212                     return;
 213                 }
 214             }
 215
 216             GetPlayer()->Whisper(msg, lang,player->GetGUID());
 217         } break;
 218
 219         case CHAT_MSG_PARTY:
 220         {
 221             std::string msg = "";
 222             recv_data >> msg;
 223
 224             if(msg.empty())
 225                 break;
 226
 227             if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
 228                 break;
 229
 230             // strip invisible characters for non-addon messages
 231             if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
 232                 stripLineInvisibleChars(msg);
 233
 234             if(msg.empty())
 235                 break;
 236
 237             // if player is in battleground, he cannot say to battleground members by /p
 238             Group *group = GetPlayer()->GetOriginalGroup();
 239             // so if player hasn't OriginalGroup and his player->GetGroup() is BG raid, then return
 240             if( !group && (!(group = GetPlayer()->GetGroup()) || group->isBGGroup()) )
 241                 return;
 242
 243             WorldPacket data;
 244             ChatHandler::FillMessageData(&data, this, CHAT_MSG_PARTY, lang, NULL, 0, msg.c_str(),NULL);
 245             group->BroadcastPacket(&data, false, group->GetMemberGroup(GetPlayer()->GetGUID()));
 246         }
 247         break;
 248         case CHAT_MSG_GUILD:
 249         {
 250             std::string msg = "";
 251             recv_data >> msg;
 252
 253             if(msg.empty())
 254                 break;
 255
 256             if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
 257                 break;
 258
 259             // strip invisible characters for non-addon messages
 260             if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
 261                 stripLineInvisibleChars(msg);
 262
 263             if(msg.empty())
 264                 break;
 265
 266             if (GetPlayer()->GetGuildId())
 267             {
 268                 Guild *guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 269                 if (guild)
 270                     guild->BroadcastToGuild(this, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
 271             }
 272
 273             break;
 274         }
 275         case CHAT_MSG_OFFICER:
 276         {
 277             std::string msg = "";
 278             recv_data >> msg;
 279
 280             if(msg.empty())
 281                 break;
 282
 283             if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
 284                 break;
 285
 286             // strip invisible characters for non-addon messages
 287             if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
 288                 stripLineInvisibleChars(msg);
 289
 290             if(msg.empty())
 291                 break;
 292
 293             if (GetPlayer()->GetGuildId())
 294             {
 295                 Guild *guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 296                 if (guild)
 297                     guild->BroadcastToOfficers(this, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
 298             }
 299             break;
 300         }
 301         case CHAT_MSG_RAID:
 302         {
 303             std::string msg="";
 304             recv_data >> msg;
 305
 306             if(msg.empty())
 307                 break;
 308
 309             if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
 310                 break;
 311
 312             // strip invisible characters for non-addon messages
 313             if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
 314                 stripLineInvisibleChars(msg);
 315
 316             if(msg.empty())
 317                 break;
 318
 319             // if player is in battleground, he cannot say to battleground members by /ra
 320             Group *group = GetPlayer()->GetOriginalGroup();
 321             // so if player hasn't OriginalGroup and his player->GetGroup() is BG raid or his group isn't raid, then return
 322             if ((!group && !(group = GetPlayer()->GetGroup())) || group->isBGGroup() || !group->isRaidGroup())
 323                 return;
 324
 325             WorldPacket data;
 326             ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID, lang, "", 0, msg.c_str(),NULL);
 327             group->BroadcastPacket(&data, false);
 328         } break;
 329         case CHAT_MSG_RAID_LEADER:
 330         {
 331             std::string msg="";
 332             recv_data >> msg;
 333
 334             if(msg.empty())
 335                 break;
 336
 337             if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
 338                 break;
 339
 340             // strip invisible characters for non-addon messages
 341             if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
 342                 stripLineInvisibleChars(msg);
 343
 344             if(msg.empty())
 345                 break;
 346
 347             // if player is in battleground, he cannot say to battleground members by /ra
 348             Group *group = GetPlayer()->GetOriginalGroup();
 349             if ((!group && !(group = GetPlayer()->GetGroup())) || group->isBGGroup() || !group->isRaidGroup())
 350                 return;
 351
 352             WorldPacket data;
 353             ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID_LEADER, lang, "", 0, msg.c_str(),NULL);
 354             group->BroadcastPacket(&data, false);
 355         } break;
 356         case CHAT_MSG_RAID_WARNING:
 357         {
 358             std::string msg="";
 359             recv_data >> msg;
 360
 361             // strip invisible characters for non-addon messages
 362             if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
 363                 stripLineInvisibleChars(msg);
 364
 365             if(msg.empty())
 366                 break;
 367
 368             Group *group = GetPlayer()->GetGroup();
 369             if(!group || !group->isRaidGroup() || !(group->IsLeader(GetPlayer()->GetGUID()) || group->IsAssistant(GetPlayer()->GetGUID())))
 370                 return;
 371
 372             WorldPacket data;
 373             //in battleground, raid warning is sent only to players in battleground - code is ok
 374             ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID_WARNING, lang, "", 0, msg.c_str(),NULL);
 375             group->BroadcastPacket(&data, false);
 376         } break;
 377
 378         case CHAT_MSG_BATTLEGROUND:
 379         {
 380             std::string msg="";
 381             recv_data >> msg;
 382
 383             // strip invisible characters for non-addon messages
 384             if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
 385                 stripLineInvisibleChars(msg);
 386
 387             if(msg.empty())
 388                 break;
 389
 390             //battleground raid is always in Player->GetGroup(), never in GetOriginalGroup()
 391             Group *group = GetPlayer()->GetGroup();
 392             if(!group || !group->isBGGroup())
 393                 return;
 394
 395             WorldPacket data;
 396             ChatHandler::FillMessageData(&data, this, CHAT_MSG_BATTLEGROUND, lang, "", 0, msg.c_str(),NULL);
 397             group->BroadcastPacket(&data, false);
 398         } break;
 399
 400         case CHAT_MSG_BATTLEGROUND_LEADER:
 401         {
 402             std::string msg="";
 403             recv_data >> msg;
 404
 405             // strip invisible characters for non-addon messages
 406             if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
 407                 stripLineInvisibleChars(msg);
 408
 409             if(msg.empty())
 410                 break;
 411
 412             //battleground raid is always in Player->GetGroup(), never in GetOriginalGroup()
 413             Group *group = GetPlayer()->GetGroup();
 414             if(!group || !group->isBGGroup() || !group->IsLeader(GetPlayer()->GetGUID()))
 415                 return;
 416
 417             WorldPacket data;
 418             ChatHandler::FillMessageData(&data, this, CHAT_MSG_BATTLEGROUND_LEADER, lang, "", 0, msg.c_str(),NULL);
 419             group->BroadcastPacket(&data, false);
 420         } break;
 421
 422         case CHAT_MSG_CHANNEL:
 423         {
 424             std::string channel = "", msg = "";
 425             recv_data >> channel;
 426
 427             // recheck
 428             CHECK_PACKET_SIZE(recv_data,4+4+(channel.size()+1)+1);
 429
 430             recv_data >> msg;
 431
 432             // strip invisible characters for non-addon messages
 433             if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
 434                 stripLineInvisibleChars(msg);
 435
 436             if(msg.empty())
 437                 break;
 438
 439             if(ChannelMgr* cMgr = channelMgr(_player->GetTeam()))
 440             {
 441                 if(Channel *chn = cMgr->GetChannel(channel,_player))
 442                     chn->Say(_player->GetGUID(),msg.c_str(),lang);
 443             }
 444         } break;
 445
 446         case CHAT_MSG_AFK:
 447         {
 448             std::string msg;
 449             recv_data >> msg;
 450
 451             if((msg.empty() || !_player->isAFK()) && !_player->isInCombat() )
 452             {
 453                 if(!_player->isAFK())
 454                 {
 455                     if(msg.empty())
 456                         msg  = GetMangosString(LANG_PLAYER_AFK_DEFAULT);
 457                     _player->afkMsg = msg;
 458                 }
 459                 _player->ToggleAFK();
 460                 if(_player->isAFK() && _player->isDND())
 461                     _player->ToggleDND();
 462             }
 463         } break;
 464
 465         case CHAT_MSG_DND:
 466         {
 467             std::string msg;
 468             recv_data >> msg;
 469
 470             if(msg.empty() || !_player->isDND())
 471             {
 472                 if(!_player->isDND())
 473                 {
 474                     if(msg.empty())
 475                         msg  = GetMangosString(LANG_PLAYER_DND_DEFAULT);
 476                     _player->dndMsg = msg;
 477                 }
 478                 _player->ToggleDND();
 479                 if(_player->isDND() && _player->isAFK())
 480                     _player->ToggleAFK();
 481             }
 482         } break;
 483
 484         default:
 485             sLog.outError("CHAT: unknown message type %u, lang: %u", type, lang);
 486             break;
 487     }
 488 }
 489
 490 void WorldSession::HandleEmoteOpcode( WorldPacket & recv_data )
 491 {
 492     if(!GetPlayer()->isAlive())
 493         return;
 494     CHECK_PACKET_SIZE(recv_data,4);
 495
 496     uint32 emote;
 497     recv_data >> emote;
 498     GetPlayer()->HandleEmoteCommand(emote);
 499 }
 500
 501 namespace MaNGOS
 502 {
 503     class EmoteChatBuilder
 504     {
 505         public:
 506             EmoteChatBuilder(Player const& pl, uint32 text_emote, uint32 emote_num, Unit const* target)
 507                 : i_player(pl), i_text_emote(text_emote), i_emote_num(emote_num), i_target(target) {}
 508
 509             void operator()(WorldPacket& data, int32 loc_idx)
 510             {
 511                 char const* nam = i_target ? i_target->GetNameForLocaleIdx(loc_idx) : NULL;
 512                 uint32 namlen = (nam ? strlen(nam) : 0) + 1;
 513
 514                 data.Initialize(SMSG_TEXT_EMOTE, (20+namlen));
 515                 data << i_player.GetGUID();
 516                 data << (uint32)i_text_emote;
 517                 data << i_emote_num;
 518                 data << (uint32)namlen;
 519                 if( namlen > 1 )
 520                     data.append(nam, namlen);
 521                 else
 522                     data << (uint8)0x00;
 523             }
 524
 525         private:
 526             Player const& i_player;
 527             uint32        i_text_emote;
 528             uint32        i_emote_num;
 529             Unit const*   i_target;
 530     };
 531 }                                                           // namespace MaNGOS
 532
 533 void WorldSession::HandleTextEmoteOpcode( WorldPacket & recv_data )
 534 {
 535     if(!GetPlayer()->isAlive())
 536         return;
 537
 538     if (!GetPlayer()->CanSpeak())
 539     {
 540         std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
 541         SendNotification(GetMangosString(LANG_WAIT_BEFORE_SPEAKING),timeStr.c_str());
 542         return;
 543     }
 544
 545     CHECK_PACKET_SIZE(recv_data,4+4+8);
 546
 547     uint32 text_emote, emoteNum;
 548     uint64 guid;
 549
 550     recv_data >> text_emote;
 551     recv_data >> emoteNum;
 552     recv_data >> guid;
 553
 554     EmotesTextEntry const *em = sEmotesTextStore.LookupEntry(text_emote);
 555     if (!em)
 556         return;
 557
 558     uint32 emote_anim = em->textid;
 559
 560     switch(emote_anim)
 561     {
 562         case EMOTE_STATE_SLEEP:
 563         case EMOTE_STATE_SIT:
 564         case EMOTE_STATE_KNEEL:
 565         case EMOTE_ONESHOT_NONE:
 566             break;
 567         default:
 568             GetPlayer()->HandleEmoteCommand(emote_anim);
 569             break;
 570     }
 571
 572     Unit* unit = ObjectAccessor::GetUnit(*_player, guid);
 573
 574     CellPair p = MaNGOS::ComputeCellPair(GetPlayer()->GetPositionX(), GetPlayer()->GetPositionY());
 575
 576     Cell cell(p);
 577     cell.data.Part.reserved = ALL_DISTRICT;
 578     cell.SetNoCreate();
 579
 580     MaNGOS::EmoteChatBuilder emote_builder(*GetPlayer(), text_emote, emoteNum, unit);
 581     MaNGOS::LocalizedPacketDo<MaNGOS::EmoteChatBuilder > emote_do(emote_builder);
 582     MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::EmoteChatBuilder > > emote_worker(GetPlayer(),sWorld.getConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE),emote_do);
 583     TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::EmoteChatBuilder > >, WorldTypeMapContainer > message(emote_worker);
 584     CellLock<GridReadGuard> cell_lock(cell, p);
 585     cell_lock->Visit(cell_lock, message, *GetPlayer()->GetMap());
 586
 587     GetPlayer()->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE, text_emote, 0, unit);
 588
 589     //Send scripted event call
 590     if (unit && unit->GetTypeId()==TYPEID_UNIT && ((Creature*)unit)->AI())
 591         ((Creature*)unit)->AI()->ReceiveEmote(GetPlayer(),text_emote);
 592 }
 593
 594 void WorldSession::HandleChatIgnoredOpcode(WorldPacket& recv_data )
 595 {
 596     CHECK_PACKET_SIZE(recv_data, 8+1);
 597
 598     uint64 iguid;
 599     uint8 unk;
 600     //sLog.outDebug("WORLD: Received CMSG_CHAT_IGNORED");
 601
 602     recv_data >> iguid;
 603     recv_data >> unk;                                       // probably related to spam reporting
 604
 605     Player *player = objmgr.GetPlayer(iguid);
 606     if(!player || !player->GetSession())
 607         return;
 608
 609     WorldPacket data;
 610     ChatHandler::FillMessageData(&data, this, CHAT_MSG_IGNORED, LANG_UNIVERSAL, NULL, GetPlayer()->GetGUID(), GetPlayer()->GetName(),NULL);
 611     player->GetSession()->SendPacket(&data);
 612 }