← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/tuxguitar/oneiric

« back to all changes in this revision

Viewing changes to src/org/herac/tuxguitar/io/tg/TGInputStream.java

  • Committer: Bazaar Package Importer
  • Author(s): Philippe Coval
  • Date: 2008-06-19 00:30:30 UTC
  • mto: (5.1.2 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20080619003030-h719szrhsngou7c6
Tags: upstream-1.0
Import upstream version 1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/org/herac/tuxguitar/io/tg/TGInputStream.java
1
 
/*
2
 
 * Created on 16-dic-2005
3
 
 *
4
 
 * TODO To change the template for this generated file go to
5
 
 * Window - Preferences - Java - Code Style - Code Templates
6
 
 */
7
 
package org.herac.tuxguitar.io.tg;
8
 
 
9
 
import java.io.DataInputStream;
10
 
import java.io.File;
11
 
import java.io.FileInputStream;
12
 
import java.io.FileNotFoundException;
13
 
import java.io.IOException;
14
 
import java.util.ArrayList;
15
 
import java.util.List;
16
 
 
17
 
import org.herac.tuxguitar.song.models.Component;
18
 
import org.herac.tuxguitar.song.models.Duration;
19
 
import org.herac.tuxguitar.song.models.InstrumentString;
20
 
import org.herac.tuxguitar.song.models.Lyric;
21
 
import org.herac.tuxguitar.song.models.Marker;
22
 
import org.herac.tuxguitar.song.models.Measure;
23
 
import org.herac.tuxguitar.song.models.MeasureHeader;
24
 
import org.herac.tuxguitar.song.models.Note;
25
 
import org.herac.tuxguitar.song.models.NoteEffect;
26
 
import org.herac.tuxguitar.song.models.RGBColor;
27
 
import org.herac.tuxguitar.song.models.Silence;
28
 
import org.herac.tuxguitar.song.models.Song;
29
 
import org.herac.tuxguitar.song.models.SongChannel;
30
 
import org.herac.tuxguitar.song.models.SongTrack;
31
 
import org.herac.tuxguitar.song.models.Tempo;
32
 
import org.herac.tuxguitar.song.models.TimeSignature;
33
 
import org.herac.tuxguitar.song.models.Tupleto;
34
 
import org.herac.tuxguitar.song.models.VelocityValues;
35
 
import org.herac.tuxguitar.song.models.effects.BendEffect;
36
 
import org.herac.tuxguitar.song.models.effects.GraceEffect;
37
 
import org.herac.tuxguitar.song.models.effects.HarmonicEffect;
38
 
import org.herac.tuxguitar.song.models.effects.TremoloBarEffect;
39
 
import org.herac.tuxguitar.song.models.effects.TremoloPickingEffect;
40
 
import org.herac.tuxguitar.song.models.effects.TrillEffect;
41
 
 
42
 
/**
43
 
 * @author julian
44
 
 *
45
 
 * TODO To change the template for this generated type comment go to
46
 
 * Window - Preferences - Java - Code Style - Code Templates
47
 
 */
48
 
public class TGInputStream extends TGStream{    
49
 
    
50
 
        private DataInputStream dataInputStream;
51
 
    
52
 
    private String version;
53
 
 
54
 
    public TGInputStream(FileInputStream file) throws FileNotFoundException {
55
 
        this.dataInputStream = new DataInputStream(file);
56
 
    }
57
 
 
58
 
    public TGInputStream(String fileName) throws FileNotFoundException {        
59
 
        this(new FileInputStream(new File(fileName)));             
60
 
    }          
61
 
    
62
 
    public boolean isSupportedVersion(String version){
63
 
        return (version.equals(TG_VERSION));
64
 
    }
65
 
    
66
 
    public boolean isSupportedVersion(){
67
 
        try{
68
 
                readVersion();
69
 
                return isSupportedVersion(version);
70
 
        }catch(Exception e){
71
 
                return false;
72
 
        }catch(Error e){
73
 
                return false;
74
 
        }       
75
 
    }    
76
 
    
77
 
    public Song read(){        
78
 
        try {     
79
 
            this.readVersion();
80
 
            Song song = this.readSong();            
81
 
            this.dataInputStream.close();
82
 
            return song;
83
 
        } catch (IOException e) {
84
 
            e.printStackTrace();
85
 
        }        
86
 
        return null;
87
 
    }
88
 
    
89
 
    private void readVersion(){
90
 
        if(this.version == null){
91
 
                this.version = readString();
92
 
        }
93
 
    }
94
 
 
95
 
    private Song readSong(){
96
 
        //leo el nombre
97
 
        String name = readString();
98
 
        
99
 
        //leo el interprete
100
 
        String interpret = readString();
101
 
        
102
 
        //leo el album
103
 
        String album = readString();
104
 
 
105
 
        //leo el autor
106
 
        String author = readString();
107
 
        
108
 
        //leo la cantidad de measure headers
109
 
        int headerCount = readShort();
110
 
        
111
 
        //leo las pistas
112
 
        long headerStart = 1000;
113
 
        MeasureHeader lastHeader = null;
114
 
        List headers = new ArrayList(headerCount);
115
 
        for(int i = 0;i < headerCount;i++){
116
 
                MeasureHeader header = readMeasureHeader(i + 1,headerStart,lastHeader);
117
 
                headers.add(header);
118
 
                headerStart += header.getLength();
119
 
                lastHeader = header;
120
 
        }        
121
 
        
122
 
        //leo la cantidad de pistas
123
 
        int trackCount = readByte();
124
 
        
125
 
        //leo las pistas
126
 
        List tracks = new ArrayList(trackCount);
127
 
        for(int i = 0;i < trackCount;i++){
128
 
            tracks.add(readTrack(i + 1,headers));
129
 
        }
130
 
        
131
 
        return new Song(name,interpret,album,author,tracks,headers,Song.MAX_VOLUME);
132
 
    }
133
 
    
134
 
    private SongTrack readTrack(int number,List headers){
135
 
        //header
136
 
        int header = readHeader();
137
 
        
138
 
        //leo el nombre
139
 
        String name = readString();
140
 
        
141
 
        //leo el canal
142
 
        SongChannel channel = readChannel();
143
 
    
144
 
        //leo la cantidad de compases
145
 
        int measureCount = headers.size();
146
 
        
147
 
        //leo los compases
148
 
        Measure lastMeasure = null;
149
 
        List measures = new ArrayList(measureCount);
150
 
        for(int i = 0;i < measureCount;i++){
151
 
                Measure measure = readMeasure((MeasureHeader)headers.get(i),lastMeasure);
152
 
            measures.add(measure);
153
 
            lastMeasure = measure;
154
 
        }                        
155
 
        
156
 
        //leo la cantidad de cuerdas
157
 
        int stringCount = readByte();
158
 
        
159
 
        //leo las cuerdas
160
 
        List strings = new ArrayList(stringCount);
161
 
        for(int i = 0;i < stringCount;i++){
162
 
            strings.add(readInstrumentString(i + 1));
163
 
        }        
164
 
        
165
 
        //leo el offset
166
 
        int offset = (SongTrack.MIN_OFFSET + readByte());
167
 
        
168
 
        //leo el color
169
 
        RGBColor color = readRGBColor();
170
 
        
171
 
        //leo el lyrics
172
 
        Lyric lyrics = new Lyric();
173
 
        if(((header & TRACK_LYRICS) != 0)){
174
 
                lyrics = readLyrics();
175
 
        }
176
 
        
177
 
        return new SongTrack(number,name,channel,measures,strings,offset,color,lyrics);
178
 
    }
179
 
    
180
 
    private MeasureHeader readMeasureHeader(int number,long start,MeasureHeader lastMeasureHeader){
181
 
        int header = readHeader();
182
 
        
183
 
        //leo el time signature
184
 
        TimeSignature timeSignature = null;
185
 
        if(((header & MEASURE_HEADER_TIMESIGNATURE) != 0)){
186
 
                timeSignature = readTimeSignature();
187
 
        }else{
188
 
                timeSignature = (TimeSignature)lastMeasureHeader.getTimeSignature().clone(); 
189
 
        }        
190
 
        
191
 
        //leo el tempo
192
 
        Tempo tempo = null;        
193
 
        if(((header & MEASURE_HEADER_TEMPO) != 0)){
194
 
                tempo = readTempo();
195
 
        }else{
196
 
                tempo = (Tempo)lastMeasureHeader.getTempo().clone();
197
 
        }        
198
 
        
199
 
        //leo el comienzo de la repeticion
200
 
        boolean repeatStart = ((header & MEASURE_HEADER_OPEN_REPEAT) != 0);           
201
 
        
202
 
        //leo el numero de repeticiones
203
 
        int numberOfRepetitions = 0;
204
 
        if(((header & MEASURE_HEADER_CLOSE_REPEAT) != 0)){
205
 
                numberOfRepetitions = readShort();   
206
 
        }
207
 
        
208
 
        //leo el marker
209
 
        Marker marker = null;
210
 
        if(((header & MEASURE_HEADER_MARKER) != 0)){
211
 
                marker = readMarker(number);
212
 
        }
213
 
        
214
 
        int tripletFeel = ((lastMeasureHeader != null)?lastMeasureHeader.getTripletFeel():MeasureHeader.TRIPLET_FEEL_NONE);
215
 
        if(((header & MEASURE_HEADER_TRIPLET_FEEL) != 0)){
216
 
                tripletFeel = readByte();
217
 
        }
218
 
        
219
 
        return new MeasureHeader(number,start,timeSignature,tempo,marker,tripletFeel,repeatStart,numberOfRepetitions);
220
 
        
221
 
    }    
222
 
    
223
 
    private Measure readMeasure(MeasureHeader measureHeader,Measure lastMeasure){
224
 
        int header = readHeader();
225
 
 
226
 
        List notes = new ArrayList();
227
 
        List silences = new ArrayList();
228
 
        
229
 
                //leo la cantidad de componentes
230
 
        Component lastComponent = null;
231
 
                int componentCount = readShort();
232
 
                for(int i = 0;i < componentCount;i++){
233
 
                        lastComponent = readComponent(measureHeader,notes,silences,lastComponent);
234
 
        }               
235
 
 
236
 
        //leo la clave
237
 
        int clef = 0;
238
 
        if(((header & MEASURE_CLEF) != 0)){
239
 
                clef = readByte();
240
 
        }else{
241
 
                clef = lastMeasure.getClef();
242
 
        }       
243
 
        
244
 
        //leo el key signature
245
 
        int keySignature = 0;
246
 
        if(((header & MEASURE_KEYSIGNATURE) != 0)){
247
 
                keySignature = readByte();
248
 
        }else{
249
 
                keySignature = lastMeasure.getKeySignature();
250
 
        } 
251
 
        
252
 
        return new Measure(measureHeader,notes,silences,clef,keySignature);
253
 
        
254
 
    }    
255
 
    
256
 
    private SongChannel readChannel(){     
257
 
        int header = readHeader();
258
 
        
259
 
        //leo el canal        
260
 
        short channel = (short)readByte();
261
 
        
262
 
        //leo el canal de efectos        
263
 
        short effectChannel = (short)readByte();
264
 
        
265
 
        //leo el instrumento        
266
 
        short instrument = (short)readByte();
267
 
        
268
 
        //leo el volumen        
269
 
        short volume = (short)readByte();
270
 
        
271
 
        //leo el balance        
272
 
        short balance = (short)readByte();
273
 
        
274
 
        //leo el chorus        
275
 
        short chorus = (short)readByte();
276
 
        
277
 
        //leo el reverb        
278
 
        short reverb = (short)readByte();
279
 
        
280
 
        //leo el phaser        
281
 
        short phaser = (short)readByte();
282
 
        
283
 
        //leo el tremolo        
284
 
        short tremolo = (short)readByte();
285
 
        
286
 
        //leo el solo        
287
 
        boolean solo = ((header & CHANNEL_SOLO) != 0);
288
 
        
289
 
        //leo el mute        
290
 
        boolean mute = ((header & CHANNEL_MUTE) != 0);
291
 
        
292
 
        return new SongChannel(channel,effectChannel,instrument,volume,balance,chorus,reverb,phaser,tremolo,solo,mute);
293
 
    }      
294
 
 
295
 
    private Component readComponent(MeasureHeader measure,List notes,List silences,Component lastComponent){        
296
 
        int header = readHeader();
297
 
        
298
 
        //leo el start
299
 
        long start = 0;
300
 
        if(lastComponent == null){
301
 
                start = measure.getStart();
302
 
        }else if(((header & COMPONENT_NEXT_BEAT) != 0)){
303
 
                start = (lastComponent.getStart() + lastComponent.getDuration().getTime());
304
 
        }else{
305
 
                start = lastComponent.getStart();
306
 
        }       
307
 
        
308
 
        //leo la duracion
309
 
        Duration duration = null;
310
 
        if(((header & COMPONENT_NEXT_DURATION) != 0)){
311
 
                duration = readDuration();      
312
 
        }else{
313
 
                duration = (Duration)lastComponent.getDuration().clone();
314
 
        }
315
 
        if(((header & COMPONENT_NOTE) != 0)){
316
 
                //leo el valor
317
 
                int value = readByte();
318
 
        
319
 
                //leo la cuerda
320
 
                int string = readByte();    
321
 
        
322
 
                //leo la ligadura
323
 
                boolean tiedNote = ((header & COMPONENT_TIEDNOTE) != 0);
324
 
        
325
 
                //leo el velocity               
326
 
                int velocity = ((lastComponent instanceof Note)?((Note)lastComponent).getVelocity():VelocityValues.DEFAULT);
327
 
                if(((header & COMPONENT_VELOCITY) != 0)){
328
 
                        velocity = readByte();
329
 
                }               
330
 
                
331
 
                //leo los efectos
332
 
                NoteEffect effect = new NoteEffect();
333
 
                if(((header & COMPONENT_EFFECT) != 0)){
334
 
                        effect = readNoteEffect();
335
 
                }
336
 
                
337
 
                Note note = new Note(value,start,duration,velocity,string,tiedNote,effect);
338
 
                notes.add(note);
339
 
                return note;
340
 
        }else if(((header & COMPONENT_SILENCE) != 1)){
341
 
                Silence silence = new Silence(start,duration); 
342
 
                silences.add(silence);
343
 
                return silence;
344
 
        }
345
 
        return null;
346
 
    }        
347
 
    
348
 
    private InstrumentString readInstrumentString(int number){
349
 
        //leo el valor
350
 
        int value = readByte();       
351
 
                
352
 
        return new InstrumentString(number,value);
353
 
    }           
354
 
    
355
 
    private Tempo readTempo(){
356
 
        //leo el valor
357
 
        int value = readShort();
358
 
        
359
 
        return new Tempo(value);
360
 
    }    
361
 
    
362
 
    
363
 
    private TimeSignature readTimeSignature(){
364
 
        //leo el numerador
365
 
        int numerator = readByte();
366
 
        
367
 
        //leo el denominador
368
 
        Duration denominator = readDuration();
369
 
        
370
 
        return new TimeSignature(numerator,denominator); 
371
 
    }
372
 
    
373
 
    private Duration readDuration(){
374
 
        int header = readHeader();        
375
 
        boolean dotted = ((header & DURATION_DOTTED) != 0);
376
 
        boolean doubleDotted = ((header & DURATION_DOUBLE_DOTTED) != 0);
377
 
        
378
 
        //leo el valor
379
 
        int value = readByte();
380
 
 
381
 
        //leo el tupleto
382
 
        Tupleto tupleto = Duration.NO_TUPLETO;
383
 
        if(((header & DURATION_TUPLETO) != 0)){
384
 
                tupleto = readTupleto();
385
 
        }
386
 
        return new Duration(value,dotted,doubleDotted,tupleto);
387
 
    }    
388
 
    
389
 
    private Tupleto readTupleto(){                
390
 
        //leo los enters
391
 
        int enters = readByte();
392
 
        
393
 
        //leo los tiempos
394
 
        int times = readByte();
395
 
        
396
 
        return new Tupleto(enters,times);
397
 
    }           
398
 
    
399
 
    private NoteEffect readNoteEffect(){
400
 
        NoteEffect effect = new NoteEffect();        
401
 
        
402
 
        int header = readHeader(3);
403
 
 
404
 
        //leo el bend
405
 
        if(((header & EFFECT_BEND) != 0)){
406
 
            effect.setBend(readBendEffect());
407
 
        }        
408
 
        
409
 
        //leo el tremolo bar
410
 
        if(((header & EFFECT_TREMOLO_BAR) != 0)){
411
 
            effect.setTremoloBar(readTremoloBarEffect());
412
 
        }
413
 
        
414
 
        //leo el harmonic
415
 
        if(((header & EFFECT_HARMONIC) != 0)){
416
 
                effect.setHarmonic(readHarmonicEffect());
417
 
        }
418
 
        
419
 
        //leo el grace
420
 
        if(((header & EFFECT_GRACE) != 0)){
421
 
            effect.setGrace(readGraceEffect());
422
 
        }
423
 
        
424
 
        //leo el trill
425
 
        if(((header & EFFECT_TRILL) != 0)){
426
 
            effect.setTrill(readTrillEffect());
427
 
        }
428
 
        
429
 
        //leo el tremolo picking
430
 
        if(((header & EFFECT_TREMOLO_PICKING) != 0)){
431
 
            effect.setTremoloPicking(readTremoloPickingEffect());
432
 
        }
433
 
        
434
 
        //vibrato
435
 
        effect.setVibrato(((header & EFFECT_VIBRATO) != 0));            
436
 
        
437
 
        //dead note        
438
 
        effect.setDeadNote(((header & EFFECT_DEAD) != 0));        
439
 
        
440
 
        //slide
441
 
        effect.setSlide(((header & EFFECT_SLIDE) != 0));        
442
 
        
443
 
        //hammer-on/pull-off
444
 
        effect.setHammer(((header & EFFECT_HAMMER) != 0));      
445
 
        
446
 
        //ghost note
447
 
        effect.setGhostNote(((header & EFFECT_GHOST) != 0));            
448
 
        
449
 
        //accentuated note
450
 
        effect.setAccentuatedNote(((header & EFFECT_ACCENTUATED) != 0));
451
 
        
452
 
        //heavy accentuated note        
453
 
        effect.setHeavyAccentuatedNote(((header & EFFECT_HEAVY_ACCENTUATED) != 0));
454
 
        
455
 
        //palm mute     
456
 
        effect.setPalmMute(((header & EFFECT_PALM_MUTE) != 0));
457
 
        
458
 
        //staccato      
459
 
        effect.setStaccato(((header & EFFECT_STACCATO) != 0));
460
 
        
461
 
        //tapping       
462
 
        effect.setTapping(((header & EFFECT_TAPPING) != 0));
463
 
        
464
 
        //slapping      
465
 
        effect.setSlapping(((header & EFFECT_SLAPPING) != 0));
466
 
        
467
 
        //popping       
468
 
        effect.setPopping(((header & EFFECT_POPPING) != 0));
469
 
        
470
 
        //fade in       
471
 
        effect.setFadeIn(((header & EFFECT_FADE_IN) != 0));        
472
 
        
473
 
        return effect;
474
 
    }
475
 
    
476
 
    private BendEffect readBendEffect(){
477
 
        BendEffect bend = new BendEffect();
478
 
        
479
 
        //leo la cantidad de puntos
480
 
        int count = readByte();
481
 
        
482
 
        for(int i = 0;i < count;i++){            
483
 
            //leo la posicion
484
 
            int position = readByte();
485
 
            
486
 
            //leo el valor
487
 
            int value = readByte();
488
 
            
489
 
            //agrego el punto
490
 
            bend.addPoint(position,value);
491
 
        }        
492
 
        return bend;
493
 
    }
494
 
    
495
 
    private TremoloBarEffect readTremoloBarEffect(){
496
 
        TremoloBarEffect tremoloBar = new TremoloBarEffect();
497
 
        
498
 
        //leo la cantidad de puntos
499
 
        int count = readByte();
500
 
        
501
 
        for(int i = 0;i < count;i++){            
502
 
            //leo la posicion
503
 
            int position = readByte();
504
 
            
505
 
            //leo el valor
506
 
            int value =  (readByte() - TremoloBarEffect.MAX_VALUE_LENGTH);
507
 
            
508
 
            //agrego el punto
509
 
            tremoloBar.addPoint(position,value);
510
 
        }        
511
 
        return tremoloBar;
512
 
    }    
513
 
        
514
 
    private HarmonicEffect readHarmonicEffect(){        
515
 
        //leo el tipo
516
 
        int type = readByte();
517
 
        
518
 
        //leo la data
519
 
        int data = 0;     
520
 
        if(type == HarmonicEffect.TYPE_ARTIFICIAL){             
521
 
                data = (HarmonicEffect.MIN_ARTIFICIAL_OFFSET + readByte());
522
 
        }else if(type == HarmonicEffect.TYPE_TAPPED){
523
 
                data = readByte();
524
 
        }               
525
 
        
526
 
        return new HarmonicEffect(type,data);
527
 
    }    
528
 
    
529
 
    private GraceEffect readGraceEffect(){              
530
 
        int header = readHeader();      
531
 
        
532
 
        boolean dead = ((header & GRACE_FLAG_DEAD) != 0) ;
533
 
        
534
 
        boolean onBeat = ((header & GRACE_FLAG_ON_BEAT) != 0) ;
535
 
        
536
 
        //leo el fret
537
 
        int fret = readByte();
538
 
        
539
 
        //leo la duracion
540
 
        int duration = readByte();
541
 
        
542
 
        //leo el velocity
543
 
        int dynamic = readByte();
544
 
        
545
 
        //leo la transicion
546
 
        int transition = readByte();
547
 
        
548
 
        return new GraceEffect(fret,duration,dynamic,transition,onBeat,dead);
549
 
    }      
550
 
    
551
 
    private TremoloPickingEffect readTremoloPickingEffect(){            
552
 
        //leo la duracion
553
 
        int value = readByte();
554
 
        
555
 
        return new TremoloPickingEffect(value);
556
 
    }   
557
 
    
558
 
    private TrillEffect readTrillEffect(){      
559
 
        //leo el fret
560
 
        int fret = readByte();
561
 
        
562
 
        //leo la duracion
563
 
        int value = readByte();
564
 
        
565
 
        return new TrillEffect(fret,value);
566
 
    }   
567
 
    
568
 
    
569
 
    
570
 
    
571
 
    private Marker readMarker(int measure){                
572
 
        //leo el titulo
573
 
        String title = readString();
574
 
        
575
 
        //leo el color
576
 
        RGBColor color = readRGBColor();
577
 
        
578
 
        return new Marker(measure,title,color);
579
 
    }      
580
 
    
581
 
    private RGBColor readRGBColor(){                
582
 
        //escribo el RGB
583
 
        int r = readShort();
584
 
        int g = readShort();
585
 
        int b = readShort();
586
 
        
587
 
        return new RGBColor(r,g,b);
588
 
    }   
589
 
    
590
 
    
591
 
    private Lyric readLyrics(){
592
 
        //leo el compas de comienzo
593
 
        int from = readShort();
594
 
        
595
 
        //leo el texto
596
 
        String lyrics = readString();
597
 
        
598
 
        return new Lyric(from,lyrics);
599
 
    }
600
 
    
601
 
    private int readByte(){
602
 
        try {
603
 
            return this.dataInputStream.read();
604
 
        } catch (IOException e) {
605
 
            e.printStackTrace();
606
 
        }
607
 
        return 0;
608
 
    }
609
 
          
610
 
    
611
 
    private int readHeader(){
612
 
        try {
613
 
            return this.dataInputStream.read();
614
 
        } catch (IOException e) {
615
 
            e.printStackTrace();
616
 
        }
617
 
        return 0;
618
 
    }
619
 
        
620
 
    private int readHeader(int bCount){
621
 
        int header = 0;        
622
 
        for(int i = bCount; i > 0; i --){       
623
 
                header += ( readHeader() << ( (8 * i) - 8 ) );
624
 
        }
625
 
        return header;
626
 
    }    
627
 
    
628
 
    private short readShort(){          
629
 
        try {
630
 
                        return this.dataInputStream.readShort();
631
 
                } catch (IOException e) {
632
 
                        e.printStackTrace();
633
 
                }        
634
 
                return 0;
635
 
    }
636
 
    
637
 
    private String readString(){
638
 
        try {
639
 
            int length = this.dataInputStream.read();
640
 
            char[] chars = new char[length];
641
 
            for(int i = 0;i < chars.length; i++){
642
 
                chars[i] = this.dataInputStream.readChar();
643
 
            }
644
 
            return String.copyValueOf(chars);
645
 
        } catch (IOException e) {            
646
 
            e.printStackTrace();
647
 
        }
648
 
        return null;
649
 
        
650
 
    }        
651
 
    
652
 
}