~ubuntu-branches/ubuntu/maverick/cdk/maverick

« back to all changes in this revision

Viewing changes to src/org/openscience/cdk/debug/DebugStrand.java

  • Committer: Bazaar Package Importer
  • Author(s): Paul Cager
  • Date: 2008-04-09 21:17:53 UTC
  • Revision ID: james.westby@ubuntu.com-20080409211753-46lmjw5z8mx5pd8d
Tags: upstream-1.0.2
ImportĀ upstreamĀ versionĀ 1.0.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* $Revision: 7636 $ $Author: egonw $ $Date: 2007-01-04 18:46:10 +0100 (Thu, 04 Jan 2007) $
 
2
 *
 
3
 * Copyright (C) 2005-2007  Egon Willighagen <egonw@users.sf.net>
 
4
 *
 
5
 * Contact: cdk-devel@lists.sourceforge.net
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or
 
8
 * modify it under the terms of the GNU Lesser General Public License
 
9
 * as published by the Free Software Foundation; either version 2.1
 
10
 * of the License, or (at your option) any later version.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU Lesser General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU Lesser General Public License
 
18
 * along with this program; if not, write to the Free Software
 
19
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 
20
 */
 
21
package org.openscience.cdk.debug;
 
22
 
 
23
import java.util.Collection;
 
24
import java.util.Hashtable;
 
25
import java.util.List;
 
26
 
 
27
import org.openscience.cdk.interfaces.IAtom;
 
28
import org.openscience.cdk.interfaces.IAtomContainer;
 
29
import org.openscience.cdk.interfaces.IAtomParity;
 
30
import org.openscience.cdk.interfaces.IBond;
 
31
import org.openscience.cdk.interfaces.IChemObjectBuilder;
 
32
import org.openscience.cdk.interfaces.IChemObjectChangeEvent;
 
33
import org.openscience.cdk.interfaces.IChemObjectListener;
 
34
import org.openscience.cdk.interfaces.IElectronContainer;
 
35
import org.openscience.cdk.interfaces.ILonePair;
 
36
import org.openscience.cdk.interfaces.IMonomer;
 
37
import org.openscience.cdk.interfaces.ISingleElectron;
 
38
import org.openscience.cdk.interfaces.IStrand;
 
39
import org.openscience.cdk.tools.LoggingTool;
 
40
 
 
41
/**
 
42
 * Debugging data class.
 
43
 * 
 
44
 * @author     egonw
 
45
 * @cdk.module datadebug
 
46
 */
 
47
public class DebugStrand extends org.openscience.cdk.Strand
 
48
    implements IStrand {
 
49
 
 
50
    private static final long serialVersionUID = 1794588804926192427L;
 
51
    
 
52
    LoggingTool logger = new LoggingTool(DebugAtomContainer.class);
 
53
 
 
54
    public void addAtomParity(IAtomParity parity) {
 
55
                logger.debug("Adding atom parity: ", parity);
 
56
                super.addAtomParity(parity);
 
57
        }
 
58
 
 
59
        public IAtomParity getAtomParity(IAtom atom) {
 
60
                logger.debug("Getting atom parity: ", atom);
 
61
                return super.getAtomParity(atom);
 
62
        }
 
63
 
 
64
        public void setAtoms(IAtom[] atoms) {
 
65
                logger.debug("Setting atoms: ", atoms.length);
 
66
                super.setAtoms(atoms);
 
67
        }
 
68
 
 
69
//      public void setElectronContainers(IElectronContainer[] electronContainers) {
 
70
//              logger.debug("Setting electron containers: ", electronContainers.length);
 
71
//              super.setElectronContainers(electronContainers);
 
72
//      }
 
73
 
 
74
        public void setAtom(int number, IAtom atom) {
 
75
                logger.debug("Setting atom at: pos=" + number, " atom=" + atom);
 
76
                super.setAtom(number, atom);
 
77
        }
 
78
 
 
79
        public IAtom getAtom(int number) {
 
80
                logger.debug("Getting atom at: ", number);
 
81
                return super.getAtom(number);
 
82
        }
 
83
 
 
84
        public IBond getBond(int number) {
 
85
                logger.debug("Getting bond at: ", number);
 
86
                return super.getBond(number);
 
87
        }
 
88
 
 
89
        public ILonePair getLonePair(int number) {
 
90
                logger.debug("Getting lone pair at: ", number);
 
91
                return super.getLonePair(number);
 
92
        }
 
93
        
 
94
        public ISingleElectron getSingleElectron(int number) {
 
95
                logger.debug("Getting single electron at: ", number);
 
96
                return super.getSingleElectron(number);
 
97
        }
 
98
        
 
99
//      public void setElectronContainer(int number, IElectronContainer electronContainer) {
 
100
//              logger.debug("Setting electron container at: pos=" + number, " electron container=" +electronContainer);
 
101
//              super.setElectronContainer(number, electronContainer);
 
102
//      }
 
103
 
 
104
//      public void setElectronContainerCount(int electronContainerCount) {
 
105
//              logger.debug("Setting electron container count: ", electronContainerCount);
 
106
//              super.setElectronContainerCount(electronContainerCount);
 
107
//      }
 
108
 
 
109
//      public void setAtomCount(int atomCount) {
 
110
//              logger.debug("Settting atom count: ", atomCount);
 
111
//              super.setAtomCount(atomCount);
 
112
//      }
 
113
 
 
114
        public java.util.Iterator atoms() {
 
115
                logger.debug("Getting atoms iterator");
 
116
                return super.atoms();
 
117
        }
 
118
 
 
119
        public java.util.Iterator bonds() {
 
120
                logger.debug("Getting bonds iterator");
 
121
                return super.bonds();
 
122
        }
 
123
        
 
124
        public java.util.Iterator lonePairs() {
 
125
                logger.debug("Getting lone pairs iterator");
 
126
                return super.lonePairs();
 
127
        }
 
128
        
 
129
        public java.util.Iterator singleElectrons() {
 
130
                logger.debug("Getting single electrons iterator");
 
131
                return super.singleElectrons();
 
132
        }
 
133
        
 
134
        public java.util.Iterator electronContainers() {
 
135
                logger.debug("Getting electron containers iterator");
 
136
                return super.electronContainers();
 
137
        }
 
138
        
 
139
        public IAtom getFirstAtom() {
 
140
                logger.debug("Getting first atom: ", super.getFirstAtom());
 
141
                return super.getFirstAtom();
 
142
        }
 
143
 
 
144
        public IAtom getLastAtom() {
 
145
                logger.debug("Getting last atom: ", super.getLastAtom());
 
146
                return super.getLastAtom();
 
147
        }
 
148
 
 
149
        public int getAtomNumber(IAtom atom) {
 
150
                logger.debug("Getting atom number: ", atom);
 
151
                return super.getAtomNumber(atom);
 
152
        }
 
153
 
 
154
        public int getBondNumber(IAtom atom1, IAtom atom2) {
 
155
                logger.debug("Getting bond number: atom1=" + atom1, " atom2=" + atom2);
 
156
                return super.getBondNumber(atom1, atom2);
 
157
        }
 
158
 
 
159
        public int getBondNumber(IBond bond) {
 
160
                logger.debug("Getting bond number: ", bond);
 
161
                return super.getBondNumber(bond);
 
162
        }
 
163
 
 
164
        public int getLonePairNumber(ILonePair bond) {
 
165
                logger.debug("Getting lone pair number: ", bond);
 
166
                return super.getLonePairNumber(bond);
 
167
        }
 
168
        
 
169
        public int getSingleElectronNumber(ISingleElectron bond) {
 
170
                logger.debug("Getting single electron number: ", bond);
 
171
                return super.getSingleElectronNumber(bond);
 
172
        }
 
173
        
 
174
        public IElectronContainer getElectronContainer(int number) {
 
175
                logger.debug("Getting electron container at: ", number);
 
176
                return super.getElectronContainer(number);
 
177
        }
 
178
 
 
179
        public IBond getBond(IAtom atom1, IAtom atom2) {
 
180
                logger.debug("Getting bond for atoms: atom1=" + atom1, " atom2=" + atom2);
 
181
                return super.getBond(atom1, atom2);
 
182
        }
 
183
        
 
184
        public int getAtomCount() {
 
185
                logger.debug("Getting atom count");
 
186
                return super.getAtomCount();
 
187
        }
 
188
 
 
189
        public int getBondCount() {
 
190
                logger.debug("Getting bond count");
 
191
                return super.getBondCount();
 
192
        }
 
193
        
 
194
        public int getLonePairCount() {
 
195
                logger.debug("Getting lone pair count");
 
196
                return super.getLonePairCount();
 
197
        }
 
198
 
 
199
        public int getSingleElectronCount() {
 
200
                logger.debug("Getting single electron count");
 
201
                return super.getSingleElectronCount();
 
202
        }
 
203
        
 
204
        public int getElectronContainerCount() {
 
205
                logger.debug("Getting electron container count");
 
206
                return super.getElectronContainerCount();
 
207
        }
 
208
 
 
209
        
 
210
//      public IAtom[] getConnectedAtoms(IAtom atom) {
 
211
//              logger.debug("Getting connected atoms for atom: ", atom);
 
212
//              return super.getConnectedAtoms(atom);
 
213
//      }
 
214
 
 
215
        public List getConnectedAtomsList(IAtom atom) {
 
216
                logger.debug("Getting connecting atoms vector for atom: ", atom);
 
217
                return super.getConnectedAtomsList(atom);
 
218
        }
 
219
 
 
220
//      public IBond[] getConnectedBonds(IAtom atom) {
 
221
//              logger.debug("Getting connected bonds for atom: ", atom);
 
222
//              return super.getConnectedBonds(atom);
 
223
//      }
 
224
 
 
225
        public List getConnectedBondsList(IAtom atom) {
 
226
                logger.debug("Getting connected bonds vector for atom: ", atom);
 
227
                return super.getConnectedBondsList(atom);
 
228
        }
 
229
 
 
230
        public List getConnectedLonePairsList(IAtom atom) {
 
231
                logger.debug("Getting lone pairs at atom: atom=" + atom, " lone pairs=" + super.getConnectedLonePairsCount(atom));
 
232
                return super.getConnectedLonePairsList(atom);
 
233
        }
 
234
        
 
235
        public List getConnectedSingleElectronsList(IAtom atom) {
 
236
                logger.debug("Getting single electrons at atom: atom=" + atom, " single electrons=" + super.getConnectedSingleElectronsCount(atom));
 
237
                return super.getConnectedSingleElectronsList(atom);
 
238
        }
 
239
        
 
240
        public java.util.List getConnectedElectronContainersList(IAtom atom) {
 
241
                logger.debug("Getting connected electron containers for atom: ", atom);
 
242
                return super.getConnectedElectronContainersList(atom);
 
243
        }
 
244
 
 
245
        public int getConnectedAtomsCount(IAtom atom) {
 
246
                logger.debug("Getting connected atoms count for atom: ", atom);
 
247
                return super.getConnectedAtomsCount(atom);
 
248
        }
 
249
        
 
250
        public int getConnectedBondsCount(IAtom atom) {
 
251
                logger.debug("Getting connected bonds count for atom: ", atom);
 
252
                return super.getConnectedBondsCount(atom);
 
253
        }
 
254
        
 
255
        public int getConnectedLonePairsCount(IAtom atom) {
 
256
                logger.debug("Getting connected lone pairs count for atom: ", atom);
 
257
                return super.getConnectedLonePairsCount(atom);
 
258
        }
 
259
        
 
260
        public int getConnectedSingleElectronsCount(IAtom atom) {
 
261
                logger.debug("Getting connected single electrons count for atom: ", atom);
 
262
                return super.getConnectedSingleElectronsCount(atom);
 
263
        }
 
264
        
 
265
        public double getBondOrderSum(IAtom atom) {
 
266
                logger.debug("Getting bond order sum for atom: ", atom);
 
267
                return super.getBondOrderSum(atom);
 
268
        }
 
269
 
 
270
        public double getMaximumBondOrder(IAtom atom) {
 
271
                logger.debug("Getting maximum bond order for atom: ", atom);
 
272
                return super.getMaximumBondOrder(atom);
 
273
        }
 
274
 
 
275
        public double getMinimumBondOrder(IAtom atom) {
 
276
                logger.debug("Getting minimum bond order for atom: ", atom);
 
277
                return super.getMinimumBondOrder(atom);
 
278
        }
 
279
 
 
280
//      public void addElectronContainers(IAtomContainer atomContainer) {
 
281
//              logger.debug("Adding electron containers from atom container: ", atomContainer);
 
282
//              super.addElectronContainers(atomContainer);
 
283
//      }
 
284
 
 
285
        public void add(IAtomContainer atomContainer) {
 
286
                logger.debug("Adding atom container: ", atomContainer);
 
287
                super.add(atomContainer);
 
288
        }
 
289
 
 
290
        public void addAtom(IAtom atom) {
 
291
                logger.debug("Adding atom: ", atom);
 
292
                super.addAtom(atom);
 
293
        }
 
294
 
 
295
        public void addBond(IBond bond) {
 
296
                logger.debug("Adding bond: ", bond);
 
297
                super.addBond(bond);
 
298
        }
 
299
 
 
300
        public void addLonePair(ILonePair ec) {
 
301
                logger.debug("Adding lone pair: ", ec);
 
302
                super.addLonePair(ec);
 
303
        }
 
304
        
 
305
        public void addSingleElectron(ISingleElectron ec) {
 
306
                logger.debug("Adding single electron: ", ec);
 
307
                super.addSingleElectron(ec);
 
308
        }
 
309
        
 
310
        public void addElectronContainer(IElectronContainer electronContainer) {
 
311
                logger.debug("Adding electron container: ", electronContainer);
 
312
                super.addElectronContainer(electronContainer);
 
313
        }
 
314
 
 
315
        public void remove(IAtomContainer atomContainer) {
 
316
                logger.debug("Removing atom container: ", atomContainer);
 
317
                super.remove(atomContainer);
 
318
        }
 
319
 
 
320
        public IElectronContainer removeElectronContainer(int position) {
 
321
                logger.debug("Removing electronContainer: ", position);
 
322
                return super.removeElectronContainer(position);
 
323
        }
 
324
 
 
325
        public void removeElectronContainer(IElectronContainer electronContainer) {
 
326
                logger.debug("Removing electron container: ", electronContainer);
 
327
                super.removeElectronContainer(electronContainer);
 
328
        }
 
329
 
 
330
        public void removeAtom(int position) {
 
331
                logger.debug("Removing atom: ", position);
 
332
                super.removeAtom(position);
 
333
        }
 
334
 
 
335
        public void removeAtom(IAtom atom) {
 
336
                logger.debug("Removing atom: ", atom);
 
337
                super.removeAtom(atom);
 
338
        }
 
339
 
 
340
        public IBond removeBond(int pos) {
 
341
                logger.debug("Removing bond at " + pos);
 
342
                return super.removeBond(pos);
 
343
        }
 
344
        
 
345
        public IBond removeBond(IAtom atom1, IAtom atom2) {
 
346
                logger.debug("Removing bond: atom1=" + atom1 + " atom2=" + atom2);
 
347
                return super.removeBond(atom1, atom2);
 
348
        }
 
349
        
 
350
        public void removeBond(IBond bond) {
 
351
                logger.debug("Removing bond=" + bond);
 
352
                super.removeBond(bond);
 
353
        }
 
354
        
 
355
        public ILonePair removeLonePair(int pos) {
 
356
                logger.debug("Removing bond at " + pos);
 
357
                return super.removeLonePair(pos);
 
358
        }
 
359
        
 
360
        public void removeLonePair(ILonePair ec) {
 
361
                logger.debug("Removing bond=" + ec);
 
362
                super.removeLonePair(ec);
 
363
        }
 
364
        
 
365
        public ISingleElectron removeSingleElectron(int pos) {
 
366
                logger.debug("Removing bond at " + pos);
 
367
                return super.removeSingleElectron(pos);
 
368
        }
 
369
        
 
370
        public void removeSingleElectron(ISingleElectron ec) {
 
371
                logger.debug("Removing bond=" + ec);
 
372
                super.removeSingleElectron(ec);
 
373
        }
 
374
        
 
375
        public void removeAtomAndConnectedElectronContainers(IAtom atom) {
 
376
                logger.debug("Removing atom and connected electron containers: ", atom);
 
377
                super.removeAtomAndConnectedElectronContainers(atom);           
 
378
        }
 
379
        
 
380
        public void removeAllElements() {
 
381
                logger.debug("Removing all elements");
 
382
                super.removeAllElements();
 
383
        }
 
384
 
 
385
        public void removeAllElectronContainers() {
 
386
                logger.debug("Removing all electron containers");
 
387
                super.removeAllElectronContainers();
 
388
        }
 
389
 
 
390
        public void removeAllBonds() {
 
391
                logger.debug("Removing all bonds");
 
392
                super.removeAllBonds();
 
393
        }
 
394
 
 
395
        public void addBond(int atom1, int atom2, double order, int stereo) {
 
396
                logger.debug("Adding bond: atom1=" + atom1 + " atom2=" + atom2, " order=" + order + " stereo=" + stereo);
 
397
                super.addBond(atom1, atom2, order, stereo);
 
398
        }
 
399
 
 
400
        public void addBond(int atom1, int atom2, double order) {
 
401
                logger.debug("Adding bond: atom1=" + atom1 + " atom2=" + atom2, " order=" + order);
 
402
                super.addBond(atom1, atom2, order);
 
403
        }
 
404
 
 
405
        public void addLonePair(int atomID) {
 
406
                logger.debug("Adding lone pair: ", atomID);
 
407
                super.addLonePair(atomID);
 
408
        }
 
409
 
 
410
        public void addSingleElectron(int atomID) {
 
411
                logger.debug("Adding single electron: ", atomID);
 
412
                super.addSingleElectron(atomID);
 
413
        }
 
414
        
 
415
        public boolean contains(IAtom atom) {
 
416
                logger.debug("Contains atom: ", atom);
 
417
                return super.contains(atom);
 
418
        }
 
419
 
 
420
        public boolean contains(IBond bond) {
 
421
                logger.debug("Contains bond: ", bond);
 
422
                return super.contains(bond);
 
423
        }
 
424
        
 
425
        public boolean contains(ILonePair ec) {
 
426
                logger.debug("Contains lone pair: ", ec);
 
427
                return super.contains(ec);
 
428
        }
 
429
        
 
430
        public boolean contains(ISingleElectron ec) {
 
431
                logger.debug("Contains single electron: ", ec);
 
432
                return super.contains(ec);
 
433
        }
 
434
        
 
435
        public boolean contains(IElectronContainer electronContainer) {
 
436
                logger.debug("Contains electron container: ", electronContainer);
 
437
                return super.contains(electronContainer);
 
438
        }
 
439
 
 
440
        public void addListener(IChemObjectListener col) {
 
441
                logger.debug("Adding listener: ", col);
 
442
                super.addListener(col);
 
443
        }
 
444
 
 
445
        public int getListenerCount() {
 
446
                logger.debug("Getting listener count: ", super.getListenerCount());
 
447
                return super.getListenerCount();
 
448
        }
 
449
 
 
450
        public void removeListener(IChemObjectListener col) {
 
451
                logger.debug("Removing listener: ", col);
 
452
                super.removeListener(col);
 
453
        }
 
454
 
 
455
        public void notifyChanged() {
 
456
                logger.debug("Notifying changed");
 
457
                super.notifyChanged();
 
458
        }
 
459
 
 
460
        public void notifyChanged(IChemObjectChangeEvent evt) {
 
461
                logger.debug("Notifying changed event: ", evt);
 
462
                super.notifyChanged(evt);
 
463
        }
 
464
 
 
465
        public void setProperty(Object description, Object property) {
 
466
                logger.debug("Setting property: ", description + "=" + property);
 
467
                super.setProperty(description, property);
 
468
        }
 
469
 
 
470
        public void removeProperty(Object description) {
 
471
                logger.debug("Removing property: ", description);
 
472
                super.removeProperty(description);
 
473
        }
 
474
 
 
475
        public Object getProperty(Object description) {
 
476
                logger.debug("Getting property: ", description + "=" + super.getProperty(description));
 
477
                return super.getProperty(description);
 
478
        }
 
479
 
 
480
        public Hashtable getProperties() {
 
481
                logger.debug("Getting properties");
 
482
                return super.getProperties();
 
483
        }
 
484
 
 
485
        public String getID() {
 
486
                logger.debug("Getting ID: ", super.getID());
 
487
                return super.getID();
 
488
        }
 
489
 
 
490
        public void setID(String identifier) {
 
491
                logger.debug("Setting ID: ", identifier);
 
492
                super.setID(identifier);
 
493
        }
 
494
 
 
495
        public void setFlag(int flag_type, boolean flag_value) {
 
496
                logger.debug("Setting flag: ", flag_type + "=" + flag_value);
 
497
                super.setFlag(flag_type, flag_value);
 
498
        }
 
499
 
 
500
        public boolean getFlag(int flag_type) {
 
501
                logger.debug("Setting flag: ", flag_type + "=" + super.getFlag(flag_type));
 
502
                return super.getFlag(flag_type);
 
503
        }
 
504
 
 
505
        public void setProperties(Hashtable properties) {
 
506
                logger.debug("Setting properties: ", properties);
 
507
                super.setProperties(properties);
 
508
        }
 
509
 
 
510
        public void setFlags(boolean[] flagsNew) {
 
511
                logger.debug("Setting flags:", flagsNew.length);
 
512
                super.setFlags(flagsNew);
 
513
        }
 
514
 
 
515
        public boolean[] getFlags() {
 
516
                logger.debug("Getting flags:", super.getFlags().length);
 
517
                return super.getFlags();
 
518
        }
 
519
 
 
520
        public Object clone() throws CloneNotSupportedException {
 
521
        Object clone = null;
 
522
        try {
 
523
                clone = super.clone();
 
524
        } catch (Exception exception) {
 
525
                logger.error("Could not clone DebugAtom: " + exception.getMessage(), exception);
 
526
                logger.debug(exception);
 
527
        }
 
528
        return clone;
 
529
        }
 
530
 
 
531
        public IChemObjectBuilder getBuilder() {
 
532
                return DebugChemObjectBuilder.getInstance();
 
533
        }
 
534
 
 
535
        public String getStrandName() {
 
536
                logger.debug("Getting strand name: ", super.getStrandName());
 
537
                return super.getStrandName();
 
538
        }
 
539
 
 
540
        public String getStrandType() {
 
541
                logger.debug("Getting strand type: ", super.getStrandType());
 
542
                return super.getStrandType();
 
543
        }
 
544
 
 
545
        public void setStrandName(String cStrandName) {
 
546
                logger.debug("Setting strand name to: ", cStrandName);
 
547
                super.setStrandName(cStrandName);
 
548
        }
 
549
 
 
550
        public void setStrandType(String cStrandType) {
 
551
                logger.debug("Setting strand type to: ", cStrandType);
 
552
                super.setStrandType(cStrandType);
 
553
        }
 
554
 
 
555
        public void addAtom(IAtom oAtom, IMonomer oMonomer) {
 
556
                logger.debug("Adding atom to monomer: ", oAtom, oMonomer);
 
557
                super.addAtom(oAtom, oMonomer);
 
558
        }
 
559
 
 
560
        public int getMonomerCount() {
 
561
                logger.debug("Getting monomer count: ", super.getMonomerCount());
 
562
                return super.getMonomerCount();
 
563
        }
 
564
 
 
565
        public IMonomer getMonomer(String cName) {
 
566
                logger.debug("Getting monomer for String: ", cName);
 
567
                return super.getMonomer(cName);
 
568
        }
 
569
 
 
570
        public Collection getMonomerNames() {
 
571
                logger.debug("Getting monomer names");
 
572
                return super.getMonomerNames();
 
573
        }
 
574
 
 
575
        public void removeMonomer(String name) {
 
576
                logger.debug("Removing monomer by string: ", name);
 
577
                super.removeMonomer(name);
 
578
        }
 
579
 
 
580
        public Hashtable getMonomers() {
 
581
                logger.debug("Getting monomers as hashtable");
 
582
                return super.getMonomers();
 
583
        }
 
584
 
 
585
        public void stateChanged(IChemObjectChangeEvent event) {
 
586
                logger.debug("Receiving state changed event: ", event);
 
587
                super.stateChanged(event);
 
588
        }
 
589
 
 
590
}