1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import os

    26

import re

    27

from types import TupleType, StringType, UnicodeType

    28

    29

import wx

    30

import wx.grid

    31

import wx.lib.buttons

    32

    33

from plcopen.structures import LOCATIONDATATYPES, TestIdentifier, IEC_KEYWORDS, DefaultType

    34

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    35

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    36

from CustomGrid import CustomGrid

    37

from CustomTable import CustomTable

    38

from LocationCellEditor import LocationCellEditor

    39

from util.BitmapLibrary import GetBitmap

    40

from PLCControler import _VariableInfos

    41

    42

#-------------------------------------------------------------------------------

    43

#                                 Helpers

    44

#-------------------------------------------------------------------------------

    45

    46

[TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, PROJECTTREE,

    47

 POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    48

] = range(10)

    49

    50

def GetVariableTableColnames(location):

    51

    _ = lambda x : x

    52

    if location:

    53

    	return ["#", _("Name"), _("Class"), _("Type"), _("Location"), _("Initial Value"), _("Option"), _("Documentation")]

    54

    return ["#", _("Name"), _("Class"), _("Type"), _("Initial Value"), _("Option"), _("Documentation")]

    55

    56

def GetOptions(constant=True, retain=True, non_retain=True):

    57

    _ = lambda x : x

    58

    options = [""]

    59

    if constant:

    60

        options.append(_("Constant"))

    61

    if retain:

    62

        options.append(_("Retain"))

    63

    if non_retain:

    64

        options.append(_("Non-Retain"))

    65

    return options

    66

OPTIONS_DICT = dict([(_(option), option) for option in GetOptions()])

    67

    68

def GetFilterChoiceTransfer():

    69

    _ = lambda x : x

    70

    return {_("All"): _("All"), _("Interface"): _("Interface"),

    71

            _("   Input"): _("Input"), _("   Output"): _("Output"), _("   InOut"): _("InOut"),

    72

            _("   External"): _("External"), _("Variables"): _("Variables"), _("   Local"): _("Local"),

    73

            _("   Temp"): _("Temp"), _("Global"): _("Global")}#, _("Access") : _("Access")}

    74

VARIABLE_CHOICES_DICT = dict([(_(_class), _class) for _class in GetFilterChoiceTransfer().iterkeys()])

    75

VARIABLE_CLASSES_DICT = dict([(_(_class), _class) for _class in GetFilterChoiceTransfer().itervalues()])

    76

    77

CheckOptionForClass = {"Local": lambda x: x,

    78

                       "Temp": lambda x: "",

    79

                       "Input": lambda x: {"Retain": "Retain", "Non-Retain": "Non-Retain"}.get(x, ""),

    80

                       "InOut": lambda x: "",

    81

                       "Output": lambda x: {"Retain": "Retain", "Non-Retain": "Non-Retain"}.get(x, ""),

    82

                       "Global": lambda x: {"Constant": "Constant", "Retain": "Retain"}.get(x, ""),

    83

                       "External": lambda x: {"Constant": "Constant"}.get(x, "")

    84

                      }

    85

    86

LOCATION_MODEL = re.compile("((?:%[IQM](?:\*|(?:[XBWLD]?[0-9]+(?:\.[0-9]+)*)))?)$")

    87

VARIABLE_NAME_SUFFIX_MODEL = re.compile("([0-9]*)$")

    88

    89

#-------------------------------------------------------------------------------

    90

#                            Variables Panel Table

    91

#-------------------------------------------------------------------------------

    92

    93

class VariableTable(CustomTable):

    94

    95

    """

    96

    A custom wx.grid.Grid Table using user supplied data

    97

    """

    98

    def __init__(self, parent, data, colnames):

    99

        # The base class must be initialized *first*

   100

        CustomTable.__init__(self, parent, data, colnames)

   101

        self.old_value = None

   102

   103

    def GetValueByName(self, row, colname):

   104

        if row < self.GetNumberRows():

   105

            return getattr(self.data[row], colname)

   106

   107

    def SetValueByName(self, row, colname, value):

   108

        if row < self.GetNumberRows():

   109

            setattr(self.data[row], colname, value)

   110

   111

    def GetValue(self, row, col):

   112

        if row < self.GetNumberRows():

   113

            if col == 0:

   114

                return self.data[row].Number

   115

            colname = self.GetColLabelValue(col, False)

   116

            if colname == "Initial Value":

   117

                colname = "InitialValue"

   118

            value = getattr(self.data[row], colname, "")

   119

            if colname == "Type" and isinstance(value, TupleType):

   120

                if value[0] == "array":

   121

                    return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "..".join(x), value[2])), value[1])

   122

            if not isinstance(value, (StringType, UnicodeType)):

   123

                value = str(value)

   124

            if colname in ["Class", "Option"]:

   125

                return _(value)

   126

            return value

   127

   128

    def SetValue(self, row, col, value):

   129

        if col < len(self.colnames):

   130

            colname = self.GetColLabelValue(col, False)

   131

            if colname == "Name":

   132

                self.old_value = getattr(self.data[row], colname)

   133

            elif colname == "Class":

   134

                value = VARIABLE_CLASSES_DICT[value]

   135

                self.SetValueByName(row, "Option", CheckOptionForClass[value](self.GetValueByName(row, "Option")))

   136

                if value == "External":

   137

                    self.SetValueByName(row, "InitialValue", "")

   138

            elif colname == "Option":

   139

                value = OPTIONS_DICT[value]

   140

            elif colname == "Initial Value":

   141

                colname = "InitialValue"

   142

            setattr(self.data[row], colname, value)

   143

   144

    def GetOldValue(self):

   145

        return self.old_value

   146

   147

    def _GetRowEdit(self, row):

   148

        row_edit = self.GetValueByName(row, "Edit")

   149

        var_type = self.Parent.GetTagName()

   150

        bodytype = self.Parent.Controler.GetEditedElementBodyType(var_type)

   151

        if bodytype in ["ST", "IL"]:

   152

            row_edit = True;

   153

        return row_edit

   154

   155

    def _updateColAttrs(self, grid):

   156

        """

   157

        wx.grid.Grid -> update the column attributes to add the

   158

        appropriate renderer given the column name.

   159

   160

        Otherwise default to the default renderer.

   161

        """

   162

        for row in range(self.GetNumberRows()):

   163

            var_class = self.GetValueByName(row, "Class")

   164

            var_type = self.GetValueByName(row, "Type")

   165

            row_highlights = self.Highlights.get(row, {})

   166

            for col in range(self.GetNumberCols()):

   167

                editor = None

   168

                renderer = None

   169

                colname = self.GetColLabelValue(col, False)

   170

                if self.Parent.Debug:

   171

                    grid.SetReadOnly(row, col, True)

   172

                else:

   173

                    if colname == "Option":

   174

                        options = GetOptions(constant = var_class in ["Local", "External", "Global"],

   175

                                             retain = self.Parent.ElementType != "function" and var_class in ["Local", "Input", "Output", "Global"],

   176

                                             non_retain = self.Parent.ElementType != "function" and var_class in ["Local", "Input", "Output"])

   177

                        if len(options) > 1:

   178

                            editor = wx.grid.GridCellChoiceEditor()

   179

                            editor.SetParameters(",".join(map(_, options)))

   180

                        else:

   181

                            grid.SetReadOnly(row, col, True)

   182

                    elif col != 0 and self._GetRowEdit(row):

   183

                        grid.SetReadOnly(row, col, False)

   184

                        if colname == "Name":

   185

                            editor = wx.grid.GridCellTextEditor()

   186

                            renderer = wx.grid.GridCellStringRenderer()

   187

                        elif colname == "Initial Value":

   188

                            if var_class not in ["External", "InOut"]:

   189

                                if self.Parent.Controler.IsEnumeratedType(var_type):

   190

                                    editor = wx.grid.GridCellChoiceEditor()

   191

                                    editor.SetParameters(",".join([""] + self.Parent.Controler.GetEnumeratedDataValues(var_type)))

   192

                                else:

   193

                                    editor = wx.grid.GridCellTextEditor()

   194

                                renderer = wx.grid.GridCellStringRenderer()

   195

                            else:

   196

                                grid.SetReadOnly(row, col, True)

   197

                        elif colname == "Location":

   198

                            if var_class in ["Local", "Global"] and self.Parent.Controler.IsLocatableType(var_type):

   199

                                editor = LocationCellEditor(self, self.Parent.Controler)

   200

                                renderer = wx.grid.GridCellStringRenderer()

   201

                            else:

   202

                                grid.SetReadOnly(row, col, True)

   203

                        elif colname == "Class":

   204

                            if len(self.Parent.ClassList) == 1:

   205

                                grid.SetReadOnly(row, col, True)

   206

                            else:

   207

                                editor = wx.grid.GridCellChoiceEditor()

   208

                                excluded = []

   209

                                if self.Parent.IsFunctionBlockType(var_type):

   210

                                    excluded.extend(["Local","Temp"])

   211

                                editor.SetParameters(",".join([_(choice) for choice in self.Parent.ClassList if choice not in excluded]))

   212

                    elif colname != "Documentation":

   213

                        grid.SetReadOnly(row, col, True)

   214

   215

                grid.SetCellEditor(row, col, editor)

   216

                grid.SetCellRenderer(row, col, renderer)

   217

   218

                if colname == "Location" and LOCATION_MODEL.match(self.GetValueByName(row, colname)) is None:

   219

                    highlight_colours = ERROR_HIGHLIGHT

   220

                else:

   221

                    highlight_colours = row_highlights.get(colname.lower(), [(wx.WHITE, wx.BLACK)])[-1]

   222

                grid.SetCellBackgroundColour(row, col, highlight_colours[0])

   223

                grid.SetCellTextColour(row, col, highlight_colours[1])

   224

            self.ResizeRow(grid, row)

   225

   226

#-------------------------------------------------------------------------------

   227

#                         Variable Panel Drop Target

   228

#-------------------------------------------------------------------------------

   229

   230

class VariableDropTarget(wx.TextDropTarget):

   231

    '''

   232

    This allows dragging a variable location from somewhere to the Location

   233

    column of a variable row.

   234

   235

    The drag source should be a TextDataObject containing a Python tuple like:

   236

        ('%ID0.0.0', 'location', 'REAL')

   237

   238

    c_ext/CFileEditor.py has an example of this (you can drag a C extension

   239

    variable to the Location column of the variable panel).

   240

    '''

   241

    def __init__(self, parent):

   242

        wx.TextDropTarget.__init__(self)

   243

        self.ParentWindow = parent

   244

   245

    def OnDropText(self, x, y, data):

   246

        self.ParentWindow.ParentWindow.Select()

   247

        x, y = self.ParentWindow.VariablesGrid.CalcUnscrolledPosition(x, y)

   248

        col = self.ParentWindow.VariablesGrid.XToCol(x)

   249

        row = self.ParentWindow.VariablesGrid.YToRow(y)

   250

        message = None

   251

        element_type = self.ParentWindow.ElementType

   252

        try:

   253

            values = eval(data)

   254

        except:

   256

            values = None

   257

        if not isinstance(values, TupleType):

   259

            values = None

   260

        if values is not None:

   261

            if col != wx.NOT_FOUND and row != wx.NOT_FOUND:

   262

                colname = self.ParentWindow.Table.GetColLabelValue(col, False)

   263

                if colname == "Location" and values[1] == "location":

   264

                    if not self.ParentWindow.Table.GetValueByName(row, "Edit"):

   265

                        message = _("Can't give a location to a function block instance")

   266

                    elif self.ParentWindow.Table.GetValueByName(row, "Class") not in ["Local", "Global"]:

   267

                        message = _("Can only give a location to local or global variables")

   268

                    else:

   269

                        location = values[0]

   270

                        variable_type = self.ParentWindow.Table.GetValueByName(row, "Type")

   271

                        base_type = self.ParentWindow.Controler.GetBaseType(variable_type)

   272

   273

                        if values[2] is not None:

   274

                            base_location_type = self.ParentWindow.Controler.GetBaseType(values[2])

   275

                            if values[2] != variable_type and base_type != base_location_type:

   276

                                message = _("Incompatible data types between \"{a1}\" and \"{a2}\"").\

   277

                                          format(a1 = values[2], a2 = variable_type)

   278

   279

                        if message is None:

   280

                            if not location.startswith("%"):

   281

                                if location[0].isdigit() and base_type != "BOOL":

   283

                                elif location[0] not in LOCATIONDATATYPES:

   285

                                elif base_type not in LOCATIONDATATYPES[location[0]]:

   286

                                    message = _("Incompatible size of data between \"{a1}\" and \"{a2}\"").\

   287

                                              format(a1 = location, a2 = variable_type)

   288

                                else:

   289

                                    dialog = wx.SingleChoiceDialog(self.ParentWindow.ParentWindow.ParentWindow,

   290

                                          _("Select a variable class:"), _("Variable class"),

   291

                                          [_("Input"), _("Output"), _("Memory")],

   292

                                          wx.DEFAULT_DIALOG_STYLE|wx.OK|wx.CANCEL)

   293

                                    if dialog.ShowModal() == wx.ID_OK:

   294

                                        selected = dialog.GetSelection()

   295

                                    else:

   296

                                        selected = None

   297

                                    dialog.Destroy()

   298

                                    if selected is None:

   299

                                        return

   300

                                    if selected == 0:

   301

                                        location = "%I" + location

   302

                                    elif selected == 1:

   303

                                        location = "%Q" + location

   304

                                    else:

   305

                                        location = "%M" + location

   306

   307

                            if message is None:

   308

                                self.ParentWindow.Table.SetValue(row, col, location)

   309

                                self.ParentWindow.Table.ResetView(self.ParentWindow.VariablesGrid)

   310

                                self.ParentWindow.SaveValues()

   311

                elif colname == "Initial Value" and values[1] == "Constant":

   312

                    if not self.ParentWindow.Table.GetValueByName(row, "Edit"):

   313

                        message = _("Can't set an initial value to a function block instance")

   314

                    else:

   315

                        self.ParentWindow.Table.SetValue(row, col, values[0])

   316

                        self.ParentWindow.Table.ResetView(self.ParentWindow.VariablesGrid)

   317

                        self.ParentWindow.SaveValues()

   318

            elif (element_type not in ["config", "resource", "function"] and values[1] == "Global" and

   319

                  self.ParentWindow.Filter in ["All", "Interface", "External"] or

   320

                  element_type != "function" and values[1] in ["location", "NamedConstant"]):

   321

                if values[1] in  ["location","NamedConstant"]:

   322

                    var_name = values[3]

   323

                else:

   324

                    var_name = values[0]

   325

                tagname = self.ParentWindow.GetTagName()

   326

                dlg = wx.TextEntryDialog(

   327

                    self.ParentWindow.ParentWindow.ParentWindow,

   328

                    _("Confirm or change variable name"),

   329

                    _('Variable Drop'), var_name)

   330

                dlg.SetValue(var_name)

   331

                var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   332

                dlg.Destroy()

   333

                if var_name is None:

   334

                    return

   335

                elif var_name.upper() in [name.upper()

   336

                        for name in self.ParentWindow.Controler.\

   337

                            GetProjectPouNames(self.ParentWindow.Debug)]:

   339

                elif not var_name.upper() in [name.upper()

   340

                        for name in self.ParentWindow.Controler.\

   341

                            GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   342

                    var_infos = self.ParentWindow.DefaultValue.copy()

   343

                    var_infos.Name = var_name

   344

                    var_infos.Type = values[2]

   345

                    var_infos.Documentation = values[4]

   346

                    if values[1] == "location":

   347

                        location = values[0]

   348

                        if not location.startswith("%"):

   349

                            dialog = wx.SingleChoiceDialog(self.ParentWindow.ParentWindow.ParentWindow,

   350

                                  _("Select a variable class:"), _("Variable class"),

   351

                                  [_("Input"), _("Output"), _("Memory")],

   352

                                  wx.DEFAULT_DIALOG_STYLE|wx.OK|wx.CANCEL)

   353

                            if dialog.ShowModal() == wx.ID_OK:

   354

                                selected = dialog.GetSelection()

   355

                            else:

   356

                                selected = None

   357

                            dialog.Destroy()

   358

                            if selected is None:

   359

                                return

   360

                            if selected == 0:

   361

                                location = "%I" + location

   362

                            elif selected == 1:

   363

                                location = "%Q" + location

   364

                            else:

   365

                                location = "%M" + location

   366

                        if element_type == "functionBlock":

   367

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   368

                                                                self.ParentWindow.Debug)

   369

                            if len(configs) == 0:

   370

                                return

   371

                            if not var_name.upper() in [name.upper()

   372

                                for name in self.ParentWindow.Controler.\

   373

                                    GetConfigurationVariableNames(configs[0])]:

   374

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   375

                                    configs[0], values[2], var_name, location, "")

   376

                            var_infos.Class = "External"

   377

                        else:

   378

                            if element_type == "program":

   379

                                var_infos.Class = "Local"

   380

                            else:

   381

                                var_infos.Class = "Global"

   382

                            var_infos.Location = location

   383

                    elif values[1] == "NamedConstant":

   384

                        if element_type in ["functionBlock","program"]:

   385

                            var_infos.Class = "Local"

   386

                            var_infos.InitialValue = values[0]

   387

                        else :

   388

                            return

   389

                    else:

   390

                        var_infos.Class = "External"

   391

                    var_infos.Number = len(self.ParentWindow.Values)

   392

                    self.ParentWindow.Values.append(var_infos)

   393

                    self.ParentWindow.SaveValues()

   394

                    self.ParentWindow.RefreshValues()

   395

                else:

   397

   398

        if message is not None:

   399

            wx.CallAfter(self.ShowMessage, message)

   400

   401

    def ShowMessage(self, message):

   402

        message = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)

   403

        message.ShowModal()

   404

        message.Destroy()

   405

   406

#-------------------------------------------------------------------------------

   407

#                               Variable Panel

   408

#-------------------------------------------------------------------------------

   409

   410

class VariablePanel(wx.Panel):

   411

   412

    def __init__(self, parent, window, controler, element_type, debug=False):

   413

        wx.Panel.__init__(self, parent, style=wx.TAB_TRAVERSAL)

   414

   415

        self.MainSizer = wx.FlexGridSizer(cols=1, hgap=10, rows=2, vgap=0)

   416

        self.MainSizer.AddGrowableCol(0)

   417

        self.MainSizer.AddGrowableRow(1)

   418

   419

        controls_sizer = wx.FlexGridSizer(cols=10, hgap=5, rows=1, vgap=5)

   420

        controls_sizer.AddGrowableCol(5)

   421

        controls_sizer.AddGrowableRow(0)

   422

        self.MainSizer.AddSizer(controls_sizer, border=5, flag=wx.GROW|wx.ALL)

   423

   424

        self.ReturnTypeLabel = wx.StaticText(self, label=_('Return Type:'))

   425

        controls_sizer.AddWindow(self.ReturnTypeLabel, flag=wx.ALIGN_CENTER_VERTICAL)

   426

   427

        self.ReturnType = wx.ComboBox(self,

   428

              size=wx.Size(145, -1), style=wx.CB_READONLY)

   429

        self.Bind(wx.EVT_COMBOBOX, self.OnReturnTypeChanged, self.ReturnType)

   430

        controls_sizer.AddWindow(self.ReturnType)

   431

   432

        self.DescriptionLabel = wx.StaticText(self, label=_('Description:'))

   433

        controls_sizer.AddWindow(self.DescriptionLabel, flag=wx.ALIGN_CENTER_VERTICAL)

   434

   435

        self.Description = wx.TextCtrl(self,

   436

              size=wx.Size(250, -1), style=wx.TE_PROCESS_ENTER)

   437

        self.Bind(wx.EVT_TEXT_ENTER, self.OnDescriptionChanged, self.Description)

   438

        self.Description.Bind(wx.EVT_KILL_FOCUS, self.OnDescriptionChanged)

   439

        controls_sizer.AddWindow(self.Description)

   440

   441

        class_filter_label = wx.StaticText(self, label=_('Class Filter:'))

   442

        controls_sizer.AddWindow(class_filter_label, flag=wx.ALIGN_CENTER_VERTICAL)

   443

   444

        self.ClassFilter = wx.ComboBox(self,

   445

              size=wx.Size(145, -1), style=wx.CB_READONLY)

   446

        self.Bind(wx.EVT_COMBOBOX, self.OnClassFilter, self.ClassFilter)

   447

        controls_sizer.AddWindow(self.ClassFilter)

   448

   449

        for name, bitmap, help in [

   450

                ("AddButton", "add_element", _("Add variable")),

   451

                ("DeleteButton", "remove_element", _("Remove variable")),

   452

                ("UpButton", "up", _("Move variable up")),

   453

                ("DownButton", "down", _("Move variable down"))]:

   454

            button = wx.lib.buttons.GenBitmapButton(self, bitmap=GetBitmap(bitmap),

   455

                  size=wx.Size(28, 28), style=wx.NO_BORDER)

   456

            button.SetToolTipString(help)

   457

            setattr(self, name, button)

   458

            controls_sizer.AddWindow(button)

   459

   460

        self.VariablesGrid = CustomGrid(self, style=wx.VSCROLL | wx.HSCROLL)

   461

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   462

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE,

   463

              self.OnVariablesGridCellChange)

   464

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK,

   465

              self.OnVariablesGridCellLeftClick)

   466

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_EDITOR_SHOWN,

   467

              self.OnVariablesGridEditorShown)

   468

        self.MainSizer.AddWindow(self.VariablesGrid, flag=wx.GROW)

   469

   470

        self.SetSizer(self.MainSizer)

   471

   472

        self.ParentWindow = window

   473

        self.Controler = controler

   474

        self.ElementType = element_type

   475

        self.Debug = debug

   476

   477

        self.RefreshHighlightsTimer = wx.Timer(self, -1)

   478

        self.Bind(wx.EVT_TIMER, self.OnRefreshHighlightsTimer,

   479

              self.RefreshHighlightsTimer)

   480

   481

        self.Filter = "All"

   482

        self.FilterChoices = []

   483

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   484

   485

        self.DefaultValue = _VariableInfos("", "", "", "", "", True, "", DefaultType, ([], []), 0)

   486

   487

        if element_type in ["config", "resource"]:

   488

            self.DefaultTypes = {"All" : "Global"}

   489

        else:

   490

            self.DefaultTypes = {"All" : "Local", "Interface" : "Input", "Variables" : "Local"}

   491

   492

        if element_type in ["config", "resource"] \

   493

        or element_type in ["program", "transition", "action"]:

   494

            # this is an element that can have located variables

   495

            self.Table = VariableTable(self, [], GetVariableTableColnames(True))

   496