/** - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
function rijndaelEncrypt(text, password) {
    password = padtolength(password, 16);
    text = Crypto.AES.encrypt(text, password, {
        mode: new Crypto.mode.ECB(Crypto.pad.ZeroPadding)
    });
    return text;
}

function rijndaelDecrypt(text, password) {
    password = padtolength(password, 16);
    text = Crypto.AES.decrypt(text, password, {
        mode: new Crypto.mode.ECB(Crypto.pad.ZeroPadding)
    });
    var i=text.length;
    for(;i>0;i--){
    	if(text.charCodeAt(i-1)!=0) break;
    }
    return text.slice(0,i);
}

/*
 * Crypto-JS v2.3.0
 * http://code.google.com/p/crypto-js/
 * Copyright (c) 2011, Jeff Mott. All rights reserved.
 * http://code.google.com/p/crypto-js/wiki/License
 */
if (typeof Crypto == "undefined" || !Crypto.util)
    (function() {
        var n = window.Crypto = {}, p = n.util = {
            rotl : function(g, j) {
                return g << j | g >>> 32 - j;
            },
            rotr : function(g, j) {
                return g << 32 - j | g >>> j;
            },
            endian : function(g) {
                if (g.constructor == Number)
                    return p.rotl(g, 8) & 16711935 | p.rotl(g, 24) & 4278255360;
                for ( var j = 0; j < g.length; j++)
                    g[j] = p.endian(g[j]);
                return g;
            },
            randomBytes : function(g) {
                for ( var j = []; g > 0; g--)
                    j.push(Math.floor(Math.random() * 256));
                return j;
            },
            bytesToWords : function(g) {
                for ( var j = [], b = 0, a = 0; b < g.length; b++, a += 8)
                    j[a >>> 5] |= g[b] << 24 - a % 32;
                return j;
            },
            wordsToBytes : function(g) {
                for ( var j = [], b = 0; b < g.length * 32; b += 8)
                    j.push(g[b >>> 5] >>> 24 - b % 32 & 255);
                return j;
            },
            bytesToHex : function(g) {
                for ( var j = [], b = 0; b < g.length; b++) {
                    j.push((g[b] >>> 4).toString(16));
                    j.push((g[b] & 15).toString(16));
                }
                return j.join("");
            },
            hexToBytes : function(g) {
                for ( var j = [], b = 0; b < g.length; b += 2)
                    j.push(parseInt(g.substr(b, 2), 16));
                return j;
            },
            bytesToBase64 : function(g) {
                return Base64.encode(o.bytesToString(g));                
            },
            base64ToBytes : function(g) {
                return o.stringToBytes(Base64.decode(g));                
            }
        };
        n = n.charenc = { };
        n.UTF8 = {
            stringToBytes: function(g) {
                return o.stringToBytes(Utf8.encode(g))
            },
            bytesToString: function(g) {
                return Utf8.decode(o.bytesToString(g))
            }
        };
        var o = n.Binary = {
            stringToBytes: function(g) {
                for (var j = [], b = 0; b < g.length; b++) 
                    j.push(g.charCodeAt(b) & 255);
                return j
            },
            bytesToString: function(g) {
                for (var j = [], b = 0; b < g.length; b++) 
                    j.push(String.fromCharCode(g[b]));
                return j.join("")
            }
        };
    })();

(function(n) {
    function p(b, a) {
        var e = b._blocksize * 4;
        return e - a.length % e;
    }
    var o = n.pad = {}, g = function(b) {
        for ( var a = b.pop(), e = 1; e < a; e++) {
            b.pop();
        }
    };
    o.NoPadding = {
        pad : function() { },
        unpad : function() { }
    };
    o.ZeroPadding = {
        pad : function(b, a) {
            var e = b._blocksize * 4, i = a.length % e;
            if (i != 0) {
                for (i = e - i; i > 0; i--) {
                    a.push(0);
                }
            }
        },
        unpad : function() { }
    };
    o.iso7816 = {
        pad : function(b, a) {
            var e = p(b, a);
            for (a.push(128); e > 1; e--) {
                a.push(0);
            }
        },
        unpad : function(b) {
            for (; b.pop() != 128;) { ; }
        }
    };
    o.ansix923 = {
        pad : function(b, a) {
            for ( var e = p(b, a), i = 1; i < e; i++) {
                a.push(0);
            }
            a.push(e);
        },
        unpad : g
    };
    o.iso10126 = {
        pad : function(b, a) {
            for ( var e = p(b, a), i = 1; i < e; i++) {
                a.push(Math.floor(Math.random() * 256));
            }
            a.push(e);
        },
        unpad : g
    };
    o.pkcs7 = {
        pad : function(b, a) {
            for ( var e = p(b, a), i = 0; i < e; i++) {
                a.push(e);
            }
        },
        unpad : g
    };
    n = n.mode = {};
    var j = n.Mode = function(b) {
        if (b) {
            this._padding = b;
        }
    };
    j.prototype = {
        encrypt : function(b, a, e) {
            this._padding.pad(b, a);
            this._doEncrypt(b, a, e);
        },
        decrypt : function(b, a, e) {
            this._doDecrypt(b, a, e);
            this._padding.unpad(a);
        },
        _padding : o.iso7816
    };
    g = (n.ECB = function() {
        j.apply(this, arguments);
    }).prototype = new j;
    g._doEncrypt = function(b, a) {
        for ( var e = b._blocksize * 4, i = 0; i < a.length; i += e) {
            b._encryptblock(a, i);
        }
    };
    g._doDecrypt = function(b, a) {
        for ( var e = b._blocksize * 4, i = 0; i < a.length; i += e) {
            b._decryptblock(a, i);
        }
    };
    g.fixOptions = function(b) {
        b.iv = [];
    };
    g = (n.CBC = function() {
        j.apply(this, arguments);
    }).prototype = new j;
    g._doEncrypt = function(b, a, e) {
        for ( var i = b._blocksize * 4, k = 0; k < a.length; k += i) {
            if (k == 0) {
                for ( var m = 0; m < i; m++) {
                    a[m] ^= e[m];
                }
            } else {
                for (m = 0; m < i; m++) {
                    a[k + m] ^= a[k + m - i];
                }
            }
            b._encryptblock(a, k);
        }
    };
    g._doDecrypt = function(b, a, e) {
        for ( var i = b._blocksize * 4, k = 0; k < a.length; k += i) {
            var m = a.slice(k, k + i);
            b._decryptblock(a, k);
            for ( var q = 0; q < i; q++) {
                a[k + q] ^= e[q];
            }
            e = m;
        }
    };
    g = (n.CFB = function() {
        j.apply(this, arguments);
    }).prototype = new j;
    g._padding = o.NoPadding;
    g._doEncrypt = function(b, a, e) {
        var i = b._blocksize * 4;
        e = e.slice(0);
        for ( var k = 0; k < a.length; k++) {
            var m = k % i;
            m == 0 && b._encryptblock(e, 0);
            a[k] ^= e[m];
            e[m] = a[k];
        }
    };
    g._doDecrypt = function(b, a, e) {
        var i = b._blocksize * 4;
        e = e.slice(0);
        for ( var k = 0; k < a.length; k++) {
            var m = k % i;
            m == 0 && b._encryptblock(e, 0);
            var q = a[k];
            a[k] ^= e[m];
            e[m] = q;
        }
    };
    n = (n.OFB = function() {
        j.apply(this, arguments);
    }).prototype = new j;
    n._padding = o.NoPadding;
    n._doEncrypt = function(b, a, e) {
        var i = b._blocksize * 4;
        e = e.slice(0);
        for ( var k = 0; k < a.length; k++) {
            k % i == 0 && b._encryptblock(e, 0);
            a[k] ^= e[k % i];
        }
    };
    n._doDecrypt = n._doEncrypt;
})(Crypto);
(function() {
    function n(f, l) {
        for ( var d = 0, c = 0; c < 8; c++) {
            if (l & 1) {
                d ^= f;
            }
            var v = f & 128;
            f = f << 1 & 255;
            if (v) {
                f ^= 27;
            }
            l >>>= 1;
        }
        return d;
    }
    for ( var p = Crypto, o = p.util, g = p.charenc.UTF8, j = [ 99, 124, 119,
            123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202,
            130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114,
            192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113,
            216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226,
            235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214,
            179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203,
            190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69,
            249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245,
            188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151,
            68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34,
            42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10,
            73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55,
            109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186,
            120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139,
            138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193,
            29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233,
            206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153,
            45, 15, 176, 84, 187, 22 ], b = [], a = 0; a < 256; a++) {
        b[j[a]] = a;
    }
    var e = [], i = [], k = [], m = [], q = [], r = [];
    for (a = 0; a < 256; a++) {
        e[a] = n(a, 2);
        i[a] = n(a, 3);
        k[a] = n(a, 9);
        m[a] = n(a, 11);
        q[a] = n(a, 13);
        r[a] = n(a, 14);
    }
    var x1=[[0x00, 0x00, 0x00, 0x00],[0x01, 0x00, 0x00, 0x00],[0x02, 0x00, 0x00, 0x00],[0x04, 0x00, 0x00, 0x00],[0x08, 0x00, 0x00, 0x00],
            [0x10, 0x00, 0x00, 0x00],[0x20, 0x00, 0x00, 0x00],[0x40, 0x00, 0x00, 0x00],[0x80, 0x00, 0x00, 0x00],[0x1b, 0x00, 0x00, 0x00],
            [0x36, 0x00, 0x00, 0x00]], x = [ 0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54 ], h = [ [], [], [], [] ], t, w, s, u = p.AES = {
        encrypt : function(f, l, d) {
            d = d || {};
            var c = d.mode || new p.mode.OFB;
            c.fixOptions && c.fixOptions(d);
            f = f.constructor == String ? g.stringToBytes(f) : f;
            var v = d.iv || o.randomBytes(u._blocksize * 4);
            //l = l.constructor == String ? p.PBKDF2(l, v, 32, {asBytes : true}) : l;
            u._init(l);
            c.encrypt(u, f, v);
            f = d.iv ? f : v.concat(f);
            return d && d.asBytes ? f : o.bytesToBase64(f);
        },
        decrypt : function(f, l, d) {
            d = d || {};
            var c = d.mode || new p.mode.OFB;
            c.fixOptions && c.fixOptions(d);
            f = f.constructor == String ? o.base64ToBytes(f) : f;
            var v = d.iv || f.splice(0, u._blocksize * 4);
            //l = l.constructor == String ? p.PBKDF2(l, v, 32, {asBytes:true}) : l;
            u._init(l);
            c.decrypt(u, f, v);
            return d && d.asBytes ? f : g.bytesToString(f);
        },
        _blocksize : 4,
        _encryptblock : function(f, l) {
            for ( var d = 0; d < u._blocksize; d++)
                for ( var c = 0; c < 4; c++)
                    h[d][c] = f[l + c * 4 + d];
            for (d = 0; d < 4; d++)
                for (c = 0; c < 4; c++)
                    h[d][c] ^= s[c][d];
            for ( var v = 1; v < w; v++) {
                for (d = 0; d < 4; d++)
                    for (c = 0; c < 4; c++)
                        h[d][c] = j[h[d][c]];
                h[1].push(h[1].shift());
                h[2].push(h[2].shift());
                h[2].push(h[2].shift());
                h[3].unshift(h[3].pop());
                for (c = 0; c < 4; c++) {
                    d = h[0][c];
                    var y = h[1][c], z = h[2][c], A = h[3][c];
                    h[0][c] = e[d] ^ i[y] ^ z ^ A;
                    h[1][c] = d ^ e[y] ^ i[z] ^ A;
                    h[2][c] = d ^ y ^ e[z] ^ i[A];
                    h[3][c] = i[d] ^ y ^ z ^ e[A]
                }
                for (d = 0; d < 4; d++)
                    for (c = 0; c < 4; c++)
                        h[d][c] ^= s[v * 4 + c][d]
            }
            for (d = 0; d < 4; d++)
                for (c = 0; c < 4; c++)
                    h[d][c] = j[h[d][c]];
            h[1].push(h[1].shift());
            h[2].push(h[2].shift());
            h[2].push(h[2].shift());
            h[3].unshift(h[3].pop());
            for (d = 0; d < 4; d++)
                for (c = 0; c < 4; c++)
                    h[d][c] ^= s[w * 4 + c][d];
            for (d = 0; d < u._blocksize; d++)
                for (c = 0; c < 4; c++)
                    f[l + c * 4 + d] = h[d][c]
        },
        _decryptblock : function(f, l) {
            for ( var d = 0; d < u._blocksize; d++)
                for ( var c = 0; c < 4; c++)
                    h[d][c] = f[l + c * 4 + d];
            for (d = 0; d < 4; d++)
                for (c = 0; c < 4; c++)
                    h[d][c] ^= s[w * 4 + c][d];
            for ( var v = 1; v < w; v++) {
                h[1].unshift(h[1].pop());
                h[2].push(h[2].shift());
                h[2].push(h[2].shift());
                h[3].push(h[3].shift());
                for (d = 0; d < 4; d++)
                    for (c = 0; c < 4; c++)
                        h[d][c] = b[h[d][c]];
                for (d = 0; d < 4; d++)
                    for (c = 0; c < 4; c++)
                        h[d][c] ^= s[(w - v) * 4 + c][d];
                for (c = 0; c < 4; c++) {
                    d = h[0][c];
                    var y = h[1][c], z = h[2][c], A = h[3][c];
                    h[0][c] = r[d] ^ m[y] ^ q[z] ^ k[A];
                    h[1][c] = k[d] ^ r[y] ^ m[z] ^ q[A];
                    h[2][c] = q[d] ^ k[y] ^ r[z] ^ m[A];
                    h[3][c] = m[d] ^ q[y] ^ k[z] ^ r[A]
                }
            }
            h[1].unshift(h[1].pop());
            h[2].push(h[2].shift());
            h[2].push(h[2].shift());
            h[3].push(h[3].shift());
            for (d = 0; d < 4; d++)
                for (c = 0; c < 4; c++)
                    h[d][c] = b[h[d][c]];
            for (d = 0; d < 4; d++)
                for (c = 0; c < 4; c++)
                    h[d][c] ^= s[c][d];
            for (d = 0; d < u._blocksize; d++)
                for (c = 0; c < 4; c++)
                    f[l + c * 4 + d] = h[d][c]
        },
        _init : function(f) {
            t = f.length / 4;
            w = t + 6;
            u._keyexpansion(f)
        },
        _keyexpansion:function(key) {
              s = [];
              var temp = new Array(4);

              for (var i=0; i<t; i++) {
                  s[i] = [key.charCodeAt(4*i)&0xff, key.charCodeAt(4*i+1)&0xff, 
                          key.charCodeAt(4*i+2)&0xff, key.charCodeAt(4*i+3)&0xff];
              }

              for (var i=t; i< u._blocksize * (w + 1); i++) {
                s[i] = new Array(4);
                for (var m=0; m<4; m++) temp[m] = s[i-1][m];
                if (i % t == 0) {
                    temp[4] = temp[0];
                    for (var m=0; m<4; m++){
                        temp[m] = temp[m+1];
                        temp[m] = j[temp[m]];
                        temp[m] ^= x1[i/t][m];
                    }                     
                } else if (t > 6 && i%t == 4) {
                    for (var m=0; m<4; m++) temp[m] = j[temp[m]];
                }
                for (var m=0; m<4; m++) s[i][m] = s[i-t][m] ^ temp[m];
              }
            }
    }
})();



/////////////////////////////////////////////////////////////////////////


function padtolength(key, len)
{
    if (key.length != len){    
        var spanlen = len - key.length%len;
        //var span = String.fromCharCode(spanlen);
        var span = " ";
        for(var i=0; i<spanlen; i++){
            key += span;
        } 
    }
    return key;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */ 
/*  Base64 class: Base 64 encoding / decoding (c) Chris Veness 2002-2010                          */ 
/*    note: depends on Utf8 class                                                                 */ 
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */ 
 
var Base64 = {};  // Base64 namespace 
 
Base64.code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; 
 
/** 
 * Encode string into Base64, as defined by RFC 4648 [http://tools.ietf.org/html/rfc4648] 
 * (instance method extending String object). As per RFC 4648, no newlines are added. 
 * 
 * @param {String} str The string to be encoded as base-64 
 * @param {Boolean} [utf8encode=false] Flag to indicate whether str is Unicode string to be encoded  
 *   to UTF8 before conversion to base64; otherwise string is assumed to be 8-bit characters 
 * @returns {String} Base64-encoded string 
 */  
Base64.encode = function(str, utf8encode) {  // http://tools.ietf.org/html/rfc4648 
  utf8encode =  (typeof utf8encode == 'undefined') ? false : utf8encode; 
  var o1, o2, o3, bits, h1, h2, h3, h4, e=[], pad = '', c, plain, coded; 
  var b64 = Base64.code; 
    
  plain = utf8encode ? Utf8.encode(str) : str; 
   
  c = plain.length % 3;  // pad string to length of multiple of 3 
  if (c > 0) { while (c++ < 3) { pad += '='; plain += '\0'; } } 
  // note: doing padding here saves us doing special-case packing for trailing 1 or 2 chars 
    
  for (c=0; c<plain.length; c+=3) {  // pack three octets into four hexets 
    o1 = plain.charCodeAt(c) & 0xff; 
    o2 = plain.charCodeAt(c+1) & 0xff; 
    o3 = plain.charCodeAt(c+2) & 0xff; 
       
    bits = o1<<16 | o2<<8 | o3; 
       
    h1 = bits>>18 & 0x3f; 
    h2 = bits>>12 & 0x3f; 
    h3 = bits>>6 & 0x3f; 
    h4 = bits & 0x3f; 
 
    // use hextets to index into code string 
    e[c/3] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4); 
  } 
  coded = e.join('');  // join() is far faster than repeated string concatenation in IE 
   
  // replace 'A's from padded nulls with '='s 
  coded = coded.slice(0, coded.length-pad.length) + pad; 
    
  return coded; 
} ;
 
/** 
 * Decode string from Base64, as defined by RFC 4648 [http://tools.ietf.org/html/rfc4648] 
 * (instance method extending String object). As per RFC 4648, newlines are not catered for. 
 * 
 * @param {String} str The string to be decoded from base-64 
 * @param {Boolean} [utf8decode=false] Flag to indicate whether str is Unicode string to be decoded  
 *   from UTF8 after conversion from base64 
 * @returns {String} decoded string 
 */  
Base64.decode = function(str, utf8decode) { 
  utf8decode =  (typeof utf8decode == 'undefined') ? false : utf8decode; 
  var o1, o2, o3, h1, h2, h3, h4, bits, d=[], plain, coded; 
  var b64 = Base64.code; 
 
  //coded = utf8decode ? str.decodeUTF8() : str;
  coded = str;
   
   
  for (var c=0; c<coded.length; c+=4) {  // unpack four hexets into three octets 
    h1 = b64.indexOf(coded.charAt(c)); 
    h2 = b64.indexOf(coded.charAt(c+1)); 
    h3 = b64.indexOf(coded.charAt(c+2)); 
    h4 = b64.indexOf(coded.charAt(c+3)); 
       
    bits = h1<<18 | h2<<12 | h3<<6 | h4; 
       
    o1 = bits>>16 & 0xff; 
    o2 = bits>>8 & 0xff; 
    o3 = bits & 0xff; 
     
    d[c/4] = String.fromCharCode(o1, o2, o3); 
    // check for padding 
    if (h4 == 0x40) d[c/4] = String.fromCharCode(o1, o2); 
    if (h3 == 0x40) d[c/4] = String.fromCharCode(o1); 
  } 
  plain = d.join('');  // join() is far faster than repeated string concatenation in IE 
  
  if(utf8decode) plain = Utf8.decode(plain); 
  return plain;  
} ;
 
 
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */ 
/*  Utf8 class: encode / decode between multi-byte Unicode characters and UTF-8 multiple          */ 
/*              single-byte character encoding (c) Chris Veness 2002-2010                         */ 
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */ 
 
var Utf8 = {};  // Utf8 namespace 
 
/** 
 * Encode multi-byte Unicode string into utf-8 multiple single-byte characters  
 * (BMP / basic multilingual plane only) 
 * 
 * Chars in range U+0080 - U+07FF are encoded in 2 chars, U+0800 - U+FFFF in 3 chars 
 * 
 * @param {String} strUni Unicode string to be encoded as UTF-8 
 * @returns {String} encoded string 
 */ 
Utf8.encode = function(strUni) { 
  // use regular expressions & String.replace callback function for better efficiency  
  // than procedural approaches 
  var strUtf = strUni.replace( 
      /[\u0080-\u07ff]/g,  // U+0080 - U+07FF => 2 bytes 110yyyyy, 10zzzzzz 
      function(c) {  
        var cc = c.charCodeAt(0); 
        return String.fromCharCode(0xc0 | cc>>6, 0x80 | cc&0x3f); } 
    ); 
  strUtf = strUtf.replace( 
      /[\u0800-\uffff]/g,  // U+0800 - U+FFFF => 3 bytes 1110xxxx, 10yyyyyy, 10zzzzzz 
      function(c) {  
        var cc = c.charCodeAt(0);  
        return String.fromCharCode(0xe0 | cc>>12, 0x80 | cc>>6&0x3F, 0x80 | cc&0x3f); } 
    ); 
  return strUtf; 
} ;
 
/** 
 * Decode utf-8 encoded string back into multi-byte Unicode characters 
 * 
 * @param {String} strUtf UTF-8 string to be decoded back to Unicode 
 * @returns {String} decoded string 
 */ 
Utf8.decode = function(strUtf) { 
  // note: decode 3-byte chars first as decoded 2-byte strings could appear to be 3-byte char! 
  var strUni = strUtf.replace( 
      /[\u00e0-\u00ef][\u0080-\u00bf][\u0080-\u00bf]/g,  // 3-byte chars 
      function(c) {  // (note parentheses for precence) 
        var cc = ((c.charCodeAt(0)&0x0f)<<12) | ((c.charCodeAt(1)&0x3f)<<6) | ( c.charCodeAt(2)&0x3f);  
        return String.fromCharCode(cc); } 
    ); 
  strUni = strUni.replace( 
      /[\u00c0-\u00df][\u0080-\u00bf]/g,                 // 2-byte chars 
      function(c) {  // (note parentheses for precence) 
        var cc = (c.charCodeAt(0)&0x1f)<<6 | c.charCodeAt(1)&0x3f; 
        return String.fromCharCode(cc); } 
    ); 
  return strUni; 
} ;