← Back to branch summary

~ubuntu-branches/ubuntu/hoary/kdemultimedia/hoary

« back to all changes in this revision

Viewing changes to noatun/noatun/modules/artseffects/artseffects.cc

  • Committer: Bazaar Package Importer
  • Author(s): Martin Schulze
  • Date: 2003-01-22 15:00:51 UTC
  • Revision ID: james.westby@ubuntu.com-20030122150051-uihwkdoxf15mi1tn
Tags: upstream-2.2.2
Import upstream version 2.2.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
noatun/noatun/modules/artseffects/artseffects.cc
 
1
/* this file was generated by the MCOP idl compiler - DO NOT EDIT */
 
2
 
 
3
#include "artseffects.h"
 
4
 
 
5
// Implementation
 
6
ExtraStereo_base *ExtraStereo_base::_create(const std::string& subClass)
 
7
{
 
8
        Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
 
9
        assert(skel);
 
10
        ExtraStereo_base *castedObject = (ExtraStereo_base *)skel->_cast(ExtraStereo_base::_IID);
 
11
        assert(castedObject);
 
12
        return castedObject;
 
13
}
 
14
 
 
15
ExtraStereo_base *ExtraStereo_base::_fromString(std::string objectref)
 
16
{
 
17
        Arts::ObjectReference r;
 
18
 
 
19
        if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
 
20
                return ExtraStereo_base::_fromReference(r,true);
 
21
        return 0;
 
22
}
 
23
 
 
24
ExtraStereo_base *ExtraStereo_base::_fromDynamicCast(const Arts::Object& object)
 
25
{
 
26
        if(object.isNull()) return 0;
 
27
 
 
28
        ExtraStereo_base *castedObject = (ExtraStereo_base *)object._base()->_cast(ExtraStereo_base::_IID);
 
29
        if(castedObject) return castedObject->_copy();
 
30
 
 
31
        return _fromString(object._toString());
 
32
}
 
33
 
 
34
ExtraStereo_base *ExtraStereo_base::_fromReference(Arts::ObjectReference r, bool needcopy)
 
35
{
 
36
        ExtraStereo_base *result;
 
37
        result = (ExtraStereo_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"ExtraStereo");
 
38
        if(result)
 
39
        {
 
40
                if(!needcopy)
 
41
                        result->_cancelCopyRemote();
 
42
        }
 
43
        else
 
44
        {
 
45
                Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
 
46
                if(conn)
 
47
                {
 
48
                        result = new ExtraStereo_stub(conn,r.objectID);
 
49
                        if(needcopy) result->_copyRemote();
 
50
                        result->_useRemote();
 
51
                        if (!result->_isCompatibleWith("ExtraStereo")) {
 
52
                                result->_release();
 
53
                                return 0;
 
54
                        }
 
55
                }
 
56
        }
 
57
        return result;
 
58
}
 
59
 
 
60
std::vector<std::string> ExtraStereo_base::_defaultPortsIn() const {
 
61
        std::vector<std::string> ret;
 
62
        ret.push_back("inleft");
 
63
        ret.push_back("inright");
 
64
        return ret;
 
65
}
 
66
std::vector<std::string> ExtraStereo_base::_defaultPortsOut() const {
 
67
        std::vector<std::string> ret;
 
68
        ret.push_back("outleft");
 
69
        ret.push_back("outright");
 
70
        return ret;
 
71
}
 
72
 
 
73
void *ExtraStereo_base::_cast(unsigned long iid)
 
74
{
 
75
        if(iid == ExtraStereo_base::_IID) return (ExtraStereo_base *)this;
 
76
        if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
 
77
        if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
 
78
        if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
 
79
        return 0;
 
80
}
 
81
 
 
82
ExtraStereo_stub::ExtraStereo_stub()
 
83
{
 
84
        // constructor for subclasses (don't use directly)
 
85
}
 
86
 
 
87
ExtraStereo_stub::ExtraStereo_stub(Arts::Connection *connection, long objectID)
 
88
        : Arts::Object_stub(connection, objectID)
 
89
{
 
90
        // constructor to create a stub for an object
 
91
}
 
92
 
 
93
float ExtraStereo_stub::intensity()
 
94
{
 
95
        long methodID = _lookupMethodFast("method:0000000f5f6765745f696e74656e736974790000000006666c6f617400000000020000000000000000");
 
96
        long requestID;
 
97
        Arts::Buffer *request, *result;
 
98
        request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
 
99
        request->patchLength();
 
100
        _connection->qSendBuffer(request);
 
101
 
 
102
        result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
 
103
        if(!result) return 0.0; // error occured
 
104
        float returnCode = result->readFloat();
 
105
        delete result;
 
106
        return returnCode;
 
107
}
 
108
 
 
109
void ExtraStereo_stub::intensity(float newValue)
 
110
{
 
111
        long methodID = _lookupMethodFast("method:0000000f5f7365745f696e74656e736974790000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
 
112
        long requestID;
 
113
        Arts::Buffer *request, *result;
 
114
        request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
 
115
        request->writeFloat(newValue);
 
116
        request->patchLength();
 
117
        _connection->qSendBuffer(request);
 
118
 
 
119
        result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
 
120
        if(result) delete result;
 
121
}
 
122
 
 
123
std::string ExtraStereo_skel::_interfaceName()
 
124
{
 
125
        return "ExtraStereo";
 
126
}
 
127
 
 
128
bool ExtraStereo_skel::_isCompatibleWith(const std::string& interfacename)
 
129
{
 
130
        if (interfacename == "ExtraStereo") return true;
 
131
        if (interfacename == "Arts::StereoEffect") return true;
 
132
        if (interfacename == "Arts::SynthModule") return true;
 
133
        if (interfacename == "Arts::Object") return true;
 
134
        return false;
 
135
}
 
136
 
 
137
std::string ExtraStereo_skel::_interfaceNameSkel()
 
138
{
 
139
        return "ExtraStereo";
 
140
}
 
141
 
 
142
// _get_intensity
 
143
static void _dispatch__ExtraStereo_00(void *object, Arts::Buffer *, Arts::Buffer *result)
 
144
{
 
145
        result->writeFloat(((ExtraStereo_skel *)object)->intensity());
 
146
}
 
147
 
 
148
// _set_intensity
 
149
static void _dispatch__ExtraStereo_01(void *object, Arts::Buffer *request, Arts::Buffer *)
 
150
{
 
151
        float newValue = request->readFloat();
 
152
        ((ExtraStereo_skel *)object)->intensity(newValue);
 
153
}
 
154
 
 
155
void ExtraStereo_skel::_buildMethodTable()
 
156
{
 
157
        Arts::Buffer m;
 
158
        m.fromString(
 
159
        "MethodTable:0000000f5f6765745f696e74656e736974790000000006666c6f61"
 
160
        "74000000000200000000000000000000000f5f7365745f696e74656e7369747900"
 
161
        "00000005766f696400000000020000000100000006666c6f617400000000096e65"
 
162
        "7756616c7565000000000000000000",
 
163
                "MethodTable"
 
164
        );
 
165
        _addMethod(_dispatch__ExtraStereo_00,this,Arts::MethodDef(m));
 
166
        _addMethod(_dispatch__ExtraStereo_01,this,Arts::MethodDef(m));
 
167
        Arts::StereoEffect_skel::_buildMethodTable();
 
168
}
 
169
 
 
170
ExtraStereo_skel::ExtraStereo_skel()
 
171
{
 
172
}
 
173
 
 
174
Arts::Object_base* ExtraStereo::_Creator() {
 
175
        return ExtraStereo_base::_create();
 
176
}
 
177
 
 
178
unsigned long ExtraStereo_base::_IID = Arts::MCOPUtils::makeIID("ExtraStereo");
 
179
 
 
180
VoiceRemoval_base *VoiceRemoval_base::_create(const std::string& subClass)
 
181
{
 
182
        Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
 
183
        assert(skel);
 
184
        VoiceRemoval_base *castedObject = (VoiceRemoval_base *)skel->_cast(VoiceRemoval_base::_IID);
 
185
        assert(castedObject);
 
186
        return castedObject;
 
187
}
 
188
 
 
189
VoiceRemoval_base *VoiceRemoval_base::_fromString(std::string objectref)
 
190
{
 
191
        Arts::ObjectReference r;
 
192
 
 
193
        if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
 
194
                return VoiceRemoval_base::_fromReference(r,true);
 
195
        return 0;
 
196
}
 
197
 
 
198
VoiceRemoval_base *VoiceRemoval_base::_fromDynamicCast(const Arts::Object& object)
 
199
{
 
200
        if(object.isNull()) return 0;
 
201
 
 
202
        VoiceRemoval_base *castedObject = (VoiceRemoval_base *)object._base()->_cast(VoiceRemoval_base::_IID);
 
203
        if(castedObject) return castedObject->_copy();
 
204
 
 
205
        return _fromString(object._toString());
 
206
}
 
207
 
 
208
VoiceRemoval_base *VoiceRemoval_base::_fromReference(Arts::ObjectReference r, bool needcopy)
 
209
{
 
210
        VoiceRemoval_base *result;
 
211
        result = (VoiceRemoval_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"VoiceRemoval");
 
212
        if(result)
 
213
        {
 
214
                if(!needcopy)
 
215
                        result->_cancelCopyRemote();
 
216
        }
 
217
        else
 
218
        {
 
219
                Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
 
220
                if(conn)
 
221
                {
 
222
                        result = new VoiceRemoval_stub(conn,r.objectID);
 
223
                        if(needcopy) result->_copyRemote();
 
224
                        result->_useRemote();
 
225
                        if (!result->_isCompatibleWith("VoiceRemoval")) {
 
226
                                result->_release();
 
227
                                return 0;
 
228
                        }
 
229
                }
 
230
        }
 
231
        return result;
 
232
}
 
233
 
 
234
std::vector<std::string> VoiceRemoval_base::_defaultPortsIn() const {
 
235
        std::vector<std::string> ret;
 
236
        ret.push_back("inleft");
 
237
        ret.push_back("inright");
 
238
        return ret;
 
239
}
 
240
std::vector<std::string> VoiceRemoval_base::_defaultPortsOut() const {
 
241
        std::vector<std::string> ret;
 
242
        ret.push_back("outleft");
 
243
        ret.push_back("outright");
 
244
        return ret;
 
245
}
 
246
 
 
247
void *VoiceRemoval_base::_cast(unsigned long iid)
 
248
{
 
249
        if(iid == VoiceRemoval_base::_IID) return (VoiceRemoval_base *)this;
 
250
        if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
 
251
        if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
 
252
        if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
 
253
        return 0;
 
254
}
 
255
 
 
256
VoiceRemoval_stub::VoiceRemoval_stub()
 
257
{
 
258
        // constructor for subclasses (don't use directly)
 
259
}
 
260
 
 
261
VoiceRemoval_stub::VoiceRemoval_stub(Arts::Connection *connection, long objectID)
 
262
        : Arts::Object_stub(connection, objectID)
 
263
{
 
264
        // constructor to create a stub for an object
 
265
}
 
266
 
 
267
std::string VoiceRemoval_skel::_interfaceName()
 
268
{
 
269
        return "VoiceRemoval";
 
270
}
 
271
 
 
272
bool VoiceRemoval_skel::_isCompatibleWith(const std::string& interfacename)
 
273
{
 
274
        if (interfacename == "VoiceRemoval") return true;
 
275
        if (interfacename == "Arts::StereoEffect") return true;
 
276
        if (interfacename == "Arts::SynthModule") return true;
 
277
        if (interfacename == "Arts::Object") return true;
 
278
        return false;
 
279
}
 
280
 
 
281
std::string VoiceRemoval_skel::_interfaceNameSkel()
 
282
{
 
283
        return "VoiceRemoval";
 
284
}
 
285
 
 
286
void VoiceRemoval_skel::_buildMethodTable()
 
287
{
 
288
        Arts::Buffer m;
 
289
        m.fromString(
 
290
        "MethodTable:",
 
291
                "MethodTable"
 
292
        );
 
293
        Arts::StereoEffect_skel::_buildMethodTable();
 
294
}
 
295
 
 
296
VoiceRemoval_skel::VoiceRemoval_skel()
 
297
{
 
298
}
 
299
 
 
300
Arts::Object_base* VoiceRemoval::_Creator() {
 
301
        return VoiceRemoval_base::_create();
 
302
}
 
303
 
 
304
unsigned long VoiceRemoval_base::_IID = Arts::MCOPUtils::makeIID("VoiceRemoval");
 
305
 
 
306
RawWriter_base *RawWriter_base::_create(const std::string& subClass)
 
307
{
 
308
        Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
 
309
        assert(skel);
 
310
        RawWriter_base *castedObject = (RawWriter_base *)skel->_cast(RawWriter_base::_IID);
 
311
        assert(castedObject);
 
312
        return castedObject;
 
313
}
 
314
 
 
315
RawWriter_base *RawWriter_base::_fromString(std::string objectref)
 
316
{
 
317
        Arts::ObjectReference r;
 
318
 
 
319
        if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
 
320
                return RawWriter_base::_fromReference(r,true);
 
321
        return 0;
 
322
}
 
323
 
 
324
RawWriter_base *RawWriter_base::_fromDynamicCast(const Arts::Object& object)
 
325
{
 
326
        if(object.isNull()) return 0;
 
327
 
 
328
        RawWriter_base *castedObject = (RawWriter_base *)object._base()->_cast(RawWriter_base::_IID);
 
329
        if(castedObject) return castedObject->_copy();
 
330
 
 
331
        return _fromString(object._toString());
 
332
}
 
333
 
 
334
RawWriter_base *RawWriter_base::_fromReference(Arts::ObjectReference r, bool needcopy)
 
335
{
 
336
        RawWriter_base *result;
 
337
        result = (RawWriter_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"RawWriter");
 
338
        if(result)
 
339
        {
 
340
                if(!needcopy)
 
341
                        result->_cancelCopyRemote();
 
342
        }
 
343
        else
 
344
        {
 
345
                Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
 
346
                if(conn)
 
347
                {
 
348
                        result = new RawWriter_stub(conn,r.objectID);
 
349
                        if(needcopy) result->_copyRemote();
 
350
                        result->_useRemote();
 
351
                        if (!result->_isCompatibleWith("RawWriter")) {
 
352
                                result->_release();
 
353
                                return 0;
 
354
                        }
 
355
                }
 
356
        }
 
357
        return result;
 
358
}
 
359
 
 
360
std::vector<std::string> RawWriter_base::_defaultPortsIn() const {
 
361
        std::vector<std::string> ret;
 
362
        ret.push_back("inleft");
 
363
        ret.push_back("inright");
 
364
        return ret;
 
365
}
 
366
std::vector<std::string> RawWriter_base::_defaultPortsOut() const {
 
367
        std::vector<std::string> ret;
 
368
        ret.push_back("outleft");
 
369
        ret.push_back("outright");
 
370
        return ret;
 
371
}
 
372
 
 
373
void *RawWriter_base::_cast(unsigned long iid)
 
374
{
 
375
        if(iid == RawWriter_base::_IID) return (RawWriter_base *)this;
 
376
        if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
 
377
        if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
 
378
        if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
 
379
        return 0;
 
380
}
 
381
 
 
382
RawWriter_stub::RawWriter_stub()
 
383
{
 
384
        // constructor for subclasses (don't use directly)
 
385
}
 
386
 
 
387
RawWriter_stub::RawWriter_stub(Arts::Connection *connection, long objectID)
 
388
        : Arts::Object_stub(connection, objectID)
 
389
{
 
390
        // constructor to create a stub for an object
 
391
}
 
392
 
 
393
std::string RawWriter_skel::_interfaceName()
 
394
{
 
395
        return "RawWriter";
 
396
}
 
397
 
 
398
bool RawWriter_skel::_isCompatibleWith(const std::string& interfacename)
 
399
{
 
400
        if (interfacename == "RawWriter") return true;
 
401
        if (interfacename == "Arts::StereoEffect") return true;
 
402
        if (interfacename == "Arts::SynthModule") return true;
 
403
        if (interfacename == "Arts::Object") return true;
 
404
        return false;
 
405
}
 
406
 
 
407
std::string RawWriter_skel::_interfaceNameSkel()
 
408
{
 
409
        return "RawWriter";
 
410
}
 
411
 
 
412
void RawWriter_skel::_buildMethodTable()
 
413
{
 
414
        Arts::Buffer m;
 
415
        m.fromString(
 
416
        "MethodTable:",
 
417
                "MethodTable"
 
418
        );
 
419
        Arts::StereoEffect_skel::_buildMethodTable();
 
420
}
 
421
 
 
422
RawWriter_skel::RawWriter_skel()
 
423
{
 
424
}
 
425
 
 
426
Arts::Object_base* RawWriter::_Creator() {
 
427
        return RawWriter_base::_create();
 
428
}
 
429
 
 
430
unsigned long RawWriter_base::_IID = Arts::MCOPUtils::makeIID("RawWriter");
 
431
 
 
432
ExtraStereoGuiFactory_base *ExtraStereoGuiFactory_base::_create(const std::string& subClass)
 
433
{
 
434
        Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
 
435
        assert(skel);
 
436
        ExtraStereoGuiFactory_base *castedObject = (ExtraStereoGuiFactory_base *)skel->_cast(ExtraStereoGuiFactory_base::_IID);
 
437
        assert(castedObject);
 
438
        return castedObject;
 
439
}
 
440
 
 
441
ExtraStereoGuiFactory_base *ExtraStereoGuiFactory_base::_fromString(std::string objectref)
 
442
{
 
443
        Arts::ObjectReference r;
 
444
 
 
445
        if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
 
446
                return ExtraStereoGuiFactory_base::_fromReference(r,true);
 
447
        return 0;
 
448
}
 
449
 
 
450
ExtraStereoGuiFactory_base *ExtraStereoGuiFactory_base::_fromDynamicCast(const Arts::Object& object)
 
451
{
 
452
        if(object.isNull()) return 0;
 
453
 
 
454
        ExtraStereoGuiFactory_base *castedObject = (ExtraStereoGuiFactory_base *)object._base()->_cast(ExtraStereoGuiFactory_base::_IID);
 
455
        if(castedObject) return castedObject->_copy();
 
456
 
 
457
        return _fromString(object._toString());
 
458
}
 
459
 
 
460
ExtraStereoGuiFactory_base *ExtraStereoGuiFactory_base::_fromReference(Arts::ObjectReference r, bool needcopy)
 
461
{
 
462
        ExtraStereoGuiFactory_base *result;
 
463
        result = (ExtraStereoGuiFactory_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"ExtraStereoGuiFactory");
 
464
        if(result)
 
465
        {
 
466
                if(!needcopy)
 
467
                        result->_cancelCopyRemote();
 
468
        }
 
469
        else
 
470
        {
 
471
                Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
 
472
                if(conn)
 
473
                {
 
474
                        result = new ExtraStereoGuiFactory_stub(conn,r.objectID);
 
475
                        if(needcopy) result->_copyRemote();
 
476
                        result->_useRemote();
 
477
                        if (!result->_isCompatibleWith("ExtraStereoGuiFactory")) {
 
478
                                result->_release();
 
479
                                return 0;
 
480
                        }
 
481
                }
 
482
        }
 
483
        return result;
 
484
}
 
485
 
 
486
std::vector<std::string> ExtraStereoGuiFactory_base::_defaultPortsIn() const {
 
487
        std::vector<std::string> ret;
 
488
        return ret;
 
489
}
 
490
std::vector<std::string> ExtraStereoGuiFactory_base::_defaultPortsOut() const {
 
491
        std::vector<std::string> ret;
 
492
        return ret;
 
493
}
 
494
 
 
495
void *ExtraStereoGuiFactory_base::_cast(unsigned long iid)
 
496
{
 
497
        if(iid == ExtraStereoGuiFactory_base::_IID) return (ExtraStereoGuiFactory_base *)this;
 
498
        if(iid == Arts::GuiFactory_base::_IID) return (Arts::GuiFactory_base *)this;
 
499
        if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
 
500
        return 0;
 
501
}
 
502
 
 
503
ExtraStereoGuiFactory_stub::ExtraStereoGuiFactory_stub()
 
504
{
 
505
        // constructor for subclasses (don't use directly)
 
506
}
 
507
 
 
508
ExtraStereoGuiFactory_stub::ExtraStereoGuiFactory_stub(Arts::Connection *connection, long objectID)
 
509
        : Arts::Object_stub(connection, objectID)
 
510
{
 
511
        // constructor to create a stub for an object
 
512
}
 
513
 
 
514
std::string ExtraStereoGuiFactory_skel::_interfaceName()
 
515
{
 
516
        return "ExtraStereoGuiFactory";
 
517
}
 
518
 
 
519
bool ExtraStereoGuiFactory_skel::_isCompatibleWith(const std::string& interfacename)
 
520
{
 
521
        if (interfacename == "ExtraStereoGuiFactory") return true;
 
522
        if (interfacename == "Arts::GuiFactory") return true;
 
523
        if (interfacename == "Arts::Object") return true;
 
524
        return false;
 
525
}
 
526
 
 
527
std::string ExtraStereoGuiFactory_skel::_interfaceNameSkel()
 
528
{
 
529
        return "ExtraStereoGuiFactory";
 
530
}
 
531
 
 
532
void ExtraStereoGuiFactory_skel::_buildMethodTable()
 
533
{
 
534
        Arts::Buffer m;
 
535
        m.fromString(
 
536
        "MethodTable:",
 
537
                "MethodTable"
 
538
        );
 
539
        Arts::GuiFactory_skel::_buildMethodTable();
 
540
}
 
541
 
 
542
ExtraStereoGuiFactory_skel::ExtraStereoGuiFactory_skel()
 
543
{
 
544
}
 
545
 
 
546
Arts::Object_base* ExtraStereoGuiFactory::_Creator() {
 
547
        return ExtraStereoGuiFactory_base::_create();
 
548
}
 
549
 
 
550
unsigned long ExtraStereoGuiFactory_base::_IID = Arts::MCOPUtils::makeIID("ExtraStereoGuiFactory");
 
551
 
 
552
static Arts::IDLFileReg IDLFileReg_artseffects("artseffects",
 
553
    "IDLFile:00000001000000000000000000000000040000000c45787472615374657265"
 
554
    "6f000000000100000013417274733a3a53746572656f45666665637400000000000000"
 
555
    "00010000000a696e74656e736974790000000006666c6f617400000000130000000000"
 
556
    "000000000000000000000d566f69636552656d6f76616c000000000100000013417274"
 
557
    "733a3a53746572656f4566666563740000000000000000000000000000000000000000"
 
558
    "0a526177577269746572000000000100000013417274733a3a53746572656f45666665"
 
559
    "6374000000000000000000000000000000000000000016457874726153746572656f47"
 
560
    "7569466163746f7279000000000100000011417274733a3a477569466163746f727900"
 
561
    "0000000000000000000000000000000000000000"
 
562
);