godprotocol 1.0.831 → 1.0.833

package/Index.js

@@ -5,5 +5,39 @@ let manager = new Manager();
 
 let initiator = manager.add_account(process.env.INITIATOR || "initiator");
 
+setTimeout(() => {
+  initiator.assembler.run(
+    `
+    @/adder
+// coder: Savvy
+
+  >num 5
+  // dimensions.0.type: number
+
+  ./subtr
+
+>sub_result  sub 7 8
+  ;
+
+  >result add num 6
+  stdout result
+
+  ;
+    `,
+    {
+      cb: (blocks) => {
+        initiator.run({
+          payload: { physical_address: `${initiator.physical_address}/adder` },
+          callback: (blks) => {
+            // console.log(blks, "blocks");
+          },
+        });
+      },
+    }
+  );
+}, 1500);
+
+create_server(null, { port_search: true });
+
 export default manager;
 export { initiator, create_server };

package/Loader_sequence/main.js

@@ -1,3 +1,5 @@
+import { _id } from "generalised-datastore/utils/functions";
+
 let num_pattern = /^[+-]?\d+(\.\d+)?$/;
 // let str_pattern = /^["'][^"']*["']$/;
 let var_pattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
@@ -12,6 +14,24 @@ class Loader {
     this.instruction_stacks = [[]];
     this.stacks = new Array(account.physical_address);
     this.markers = new Array();
+    this.program_configs = new Array();
+    this.programs_index = -1;
+
+    // Code Repository
+    this.oracle = this.account.manager.oracle;
+    this.programs_folder = this.oracle.get_folder("programs", {
+      joins: ["codes"],
+    });
+    this.codes_folder = this.oracle.get_folder("codes");
+
+    this.globals = this.oracle.get_folder("globals", {
+      subfolder: ["global"],
+    });
+
+    if (!this.globals.readone({ global: "programs" }))
+      this.globals.write({ global: "programs", programs: [] });
+    if (!this.globals.readone({ global: "codes" }))
+      this.globals.write({ global: "codes", codes: [] });
   }
 
   instruction_index = () => {
@@ -220,6 +240,7 @@ class Loader {
       if (line.type === "address")
         return this.push_instruction(`pop ${path[path.length - 1]}`);
     } else {
+      this.current_program().dimensions.push({ name: identifier.value });
       this.push_instruction(`chain ${identifier.value}`);
       this.stack_instruction([
         `link ${this.stacks.slice(-1)[0]}`,
@@ -253,6 +274,10 @@ class Loader {
     } else this.push_instruction(`pop ${identifier.value}`);
   };
 
+  current_program = () => {
+    return this.program_configs[this.programs_index];
+  };
+
   marker_pattern = /@[a-zA-Z_][a-zA-Z0-9_]*/;
 
   parse_opcode = (line) => {
@@ -322,11 +347,23 @@ class Loader {
     let curr_stack = this.stacks.slice(-1)[0].split("/");
     new_stack = new_stack.split("/");
 
+    let physical_address = new_stack.join("/");
+    let program = {
+      program_name: new_stack[new_stack.length - 1],
+      physical_address,
+      codes: [],
+      dimensions: [],
+      sub_programs: [],
+      _id: _id("programs"),
+    };
+    let curr_program = this.current_program();
+    if (curr_program) curr_program.sub_programs.push(program._id);
+
+    this.programs_index++;
+    this.program_configs.push(program);
+
     if (curr_stack[1] !== new_stack[1]) {
     } else {
-      let i = 0;
-      while (curr_stack[i] === new_stack[i]) i++;
-
       for (let j = 2; j < new_stack.length; j++)
         this.stack_instruction(`chain ${new_stack[j]}`);
 
@@ -358,6 +395,7 @@ class Loader {
       this.stack_instruction(`pop ${addr[j]}`);
 
     this.instructions.push(...this.instruction_stacks.splice(-1)[0]);
+    this.programs_index--;
 
     this.instruction_indexes.pop();
   };
@@ -414,11 +452,47 @@ class Loader {
     return line;
   };
 
+  parse_comment = (line) => {
+    line = line.split(":");
+    if (line.length <= 1) return;
+
+    let curr_program = this.current_program();
+    let line1 = line[0].split(".");
+    let obj = curr_program;
+
+    for (let l = 0; l < line1.length - 1; l++) {
+      let term = line1[l];
+
+      if (term.trim() === "_id") break;
+
+      let n_term = Number(term);
+
+      if (n_term) {
+        obj = obj[n_term];
+      } else obj = obj[term];
+    }
+    if (!obj) return;
+
+    let index = line1[line1.length - 1];
+    let n_indx = Number(index);
+    if (!isNaN(n_indx)) index = n_indx;
+
+    if (index === "_id") return;
+
+    obj[index] = line.slice(1).join(":").trim();
+  };
+
   compile = (codes) => {
     let code_array = codes.split("\n");
 
     for (let c = 0; c < code_array.length; c++) {
       let line = code_array[c].trim();
+
+      let curr_program = this.current_program();
+      this.is_routine = line.startsWith(".") || line.startsWith("@");
+
+      this.handle_codes(line, curr_program);
+
       if (!line) continue;
 
       if (line.startsWith(":")) {
@@ -430,15 +504,31 @@ class Loader {
       line = this.resolve_offset(line);
 
       if (line === ";") this.pop();
-      else if (line.startsWith(".") || line.startsWith("@"))
-        this.parse_routine(line);
-      else if (line.startsWith("//")) continue;
+      else if (this.is_routine) this.parse_routine(line);
+      else if (line.startsWith("//")) this.parse_comment(line.slice(2).trim());
       else if (line.startsWith(">@")) this.parse_assignment(line, true);
       else if (line.startsWith(">")) this.parse_assignment(line);
       else this.parse_opcode(line);
+
+      (!curr_program || this.is_routine) &&
+        this.handle_codes(line, this.current_program());
     }
   };
 
+  handle_codes = (line, curr_program) => {
+    if (this.is_routine) {
+      let tilline = `~${line}`;
+      let prev_program = this.program_configs[this.programs_index - 1];
+      prev_program && prev_program.codes.push(tilline);
+
+      curr_program &&
+        !curr_program.codes.find((line) => !!line.trim()) &&
+        curr_program.codes.push(line);
+    }
+
+    !this.is_routine && curr_program && curr_program.codes.push(line);
+  };
+
   run = (codes, meta) => {
     if (!meta) meta = {};
     this.pure = meta && meta.pure;
@@ -453,6 +543,50 @@ class Loader {
       program: { instructions: [...this.instructions] },
       callback: cb,
     });
+
+    let programs = this.globals.readone({ global: "programs" });
+    let codes_global = this.globals.readone({ global: "codes" });
+    this.program_configs.map((config) => {
+      let program = programs.programs.find(
+        (prog) => prog.physical_address === config.physical_address
+      );
+
+      let code_str = config.codes.join("\n");
+      let code_hash = this.oracle.hash(code_str);
+      let code = codes_global.codes.find((cod) => cod.hash === code_hash);
+      let code_id = code && code.code_id;
+      if (!code_id) {
+        code_id = _id("codes");
+
+        this.globals.update(
+          { global: "codes" },
+          { codes: { $unshift: { code_id, hash: code_hash } } }
+        );
+      }
+
+      if (program) {
+        config._id = program.program_id;
+        this.programs_folder.update(config._id, {
+          ...config,
+          codes: { $unshift: code_id },
+        });
+      } else {
+        this.programs_folder.write({ ...config, codes: [code_id] });
+        this.globals.update(
+          { global: "programs" },
+          {
+            programs: {
+              $unshift: {
+                physical_address: config.physical_address,
+                program_id: config._id,
+              },
+            },
+          }
+        );
+      }
+      !code && this.codes_folder.write({ codes: code_str, _id: code_id });
+    });
+    this.program_configs = [];
     this.instructions = [];
     this.pure = false;
   };

package/Objects/Account.js

@@ -88,11 +88,11 @@ class Account extends Filesystem {
     buffer.blocks.push(block.stringify());
   };
 
-  flush_buffer = (pid) => {
+  flush_buffer = (pid, payload) => {
     let buff = this.mine_buffer[pid];
     if (!buff) return;
 
-    buff.callback && this.run_callback(buff.callback, buff.blocks);
+    buff.callback && this.run_callback(buff.callback, payload || buff.blocks);
     delete this.mine_buffer[pid];
   };
 
@@ -110,35 +110,29 @@ class Account extends Filesystem {
   };
 
   parse = (program) => {
-    let { payload, signature, callback } = program;
-    let { physical_address, account, query } = payload;
+    let { payload, callback } = program;
+    let { account } = payload;
     account = this.get_account(account);
-    this.propagate(program, "parse");
-
-    if (!account.validate(payload, signature))
-      return this.run_callback(callback, {
-        private: account.private,
-        error: true,
-        error_message: "Invalid signature",
-      });
-
-    let chain = account.manager.web.get(physical_address);
-
-    if (!chain)
-      return this.run_callback(callback, {
-        error: true,
-        error_message: "Address not found",
-      });
-
-    let data = query ? chain.explore(query) : chain;
-
-    this.run_callback(callback, data && data.stringify());
+    account.propagate(program, "parse");
+
+    account.manager.oracle.fetch(
+      payload,
+      (result) => account.run_callback(callback, result),
+      () =>
+        account.run_callback(callback, {
+          private: account.private,
+          error: true,
+          error_message: "Invalid signature",
+        })
+    );
   };
 
   run = (request) => {
     let { payload, signature, callback } = request;
 
-    let { physical_address, account, query } = payload;
+    let { physical_address, account, query, history } = payload;
+
+    history = Math.abs(Number(history)) || 0;
     account = this.get_account(account);
     account.propagate(request, "run");
 
@@ -150,10 +144,38 @@ class Account extends Filesystem {
       ? this.manager.web.get(physical_address)
       : account.vm.get_context();
 
-    if (!context) return account.flush_buffer(pid);
+    if (!context) {
+      if (physical_address)
+        context = this.manager.web.split_set(physical_address);
+      else return account.flush_buffer(pid);
+    }
 
     let blk = query ? context.explore(query) : context.get_latest_block();
 
+    if (!query) {
+      let index = context.height;
+      index -= 2;
+
+      if (blk && blk.metadata.program) {
+        if (history) {
+          history--;
+          blk = null;
+        }
+      }
+
+      while (!blk && index >= 0) {
+        index--;
+        blk = context.get_block(index);
+
+        if (blk && blk.metadata.program) {
+          if (history) {
+            history--;
+            blk = null;
+          }
+        }
+      }
+    }
+
     if (blk && blk.metadata && blk.metadata.program) {
       let program = this.read(blk.metadata.program);
 
@@ -183,6 +205,11 @@ class Account extends Filesystem {
   };
 
   flush_stdout = (block) => {
+    if (
+      block.chain.physical_address === `${this.physical_address}/Opcodes/stdout`
+    )
+      return;
+
     for (let s = 0; s < this.stdout.length; s++) {
       let out = this.stdout[s];
       if (out.pid === this.vm.track.pid) {

package/Objects/Block.js

@@ -1,4 +1,5 @@
 import { hash } from "../utils/hash";
+import { _id } from "generalised-datastore/utils/functions";
 
 class Block {
   constructor(chain) {
@@ -7,6 +8,7 @@ class Block {
     this.metadata = {};
     this.children = new Array();
     this.index = this.chain.blocks.length;
+    this._id = _id(this.chain.hash);
 
     this.blocks_folder = this.chain.account.manager.oracle.gds.folder(
       process.env.BLOCKS_FOLDER || "blocks"
@@ -51,13 +53,16 @@ class Block {
     obj.index = this.index;
     obj.hash = this.hash;
     obj.data = this.data;
-    obj.children = this.children.map(
-      (ch) =>
-        new Object({
-          hash: ch.hash,
-          chain: ch.chain.hash,
-          physical_address: ch.chain.physical_address,
-        })
+    obj._id = this._id;
+    obj.children = this.children.map((ch) =>
+      ch.stringify
+        ? new Object({
+            hash: ch.hash,
+            chain: ch.chain.hash,
+            _id: ch._id,
+            physical_address: ch.chain.physical_address,
+          })
+        : ch
     );
     obj.chain = {
       hash: this.chain.hash,
@@ -66,6 +71,22 @@ class Block {
 
     return str ? JSON.stringify(obj) : obj;
   };
+
+  static build = (data, chain) => {
+    let blck = new Block(chain);
+    blck.chain = chain;
+    blck.metadata = data.metadata;
+    blck.datapath = data.datapath;
+    blck.timelapse = data.timelapse;
+    blck.index = data.index;
+    blck.hash = data.hash;
+    blck.data = data.data;
+    blck.children = data.children || [];
+
+    blck._id = data._id;
+
+    return blck;
+  };
 }
 
 export default Block;

package/Objects/Blockweb.js

@@ -15,7 +15,21 @@ class Blockweb {
     return chain;
   };
 
+  split_set = (physical_address) => {
+    let spli = physical_address.split("/");
+
+    let chain = this.get(physical_address);
+    if (!chain) {
+      chain = this.set(spli.slice(0, -1).join("/"), spli.slice(-1)[0]);
+    }
+    return chain;
+  };
+
   set = (parent, name) => {
+    if (typeof parent === "string") {
+      parent = this.get(parent) || this.split_set(parent);
+    }
+
     let chain = new Chain(parent, name);
     this.chains[chain.hash] = chain;
 

package/Objects/Chain.js

@@ -28,13 +28,25 @@ class Chain extends Explorer {
     this.generate_hash();
 
     this.folder = this.account.manager.oracle.gds.folder(this.hash);
+    this.height = this.folder.config.total_files;
+    this.prev_hash = this.folder.config.recent_file;
 
-    this.manage_config();
+    this.manage_config(true);
 
     this.account.set_paths(this);
   }
 
-  manage_config = () => {};
+  manage_config = (init) => {
+    if (init) {
+      let dir = this.account.manager.oracle.fs.readdirSync(
+        this.folder.folder_path
+      );
+      this.blocks = dir.filter((d) => d !== ".config");
+      this.height = this.blocks.length;
+    }
+
+    this.folder.config.object = { ...this.stringify() };
+  };
 
   append_buffer = () => {
     this.buffs.push({});
@@ -56,8 +68,18 @@ class Chain extends Explorer {
     this.hash = hash(this.physical_address);
   };
 
+  build_block = (blk) => {
+    if (typeof blk === "string") {
+      let blk_data = this.folder.readone(blk);
+
+      blk = Block.build(blk_data, this);
+    }
+    return blk;
+  };
+
   get_block = (index) => {
-    return this.blocks[index];
+    let blk = this.blocks[index];
+    return this.build_block(blk);
   };
 
   add_tx = (instruction) => {
@@ -87,7 +109,17 @@ class Chain extends Explorer {
 
     block.timelapse = Date.now() - this.start_time;
 
-    this.folder.write(block.stringify());
+    this.manage_config();
+
+    let data = block.stringify();
+
+    data = this.account.manager.oracle.handle_compression({
+      addr: this.folder.folder_path,
+      data,
+      no_string: true,
+    });
+
+    this.folder.write(data);
     return block;
   };
 
@@ -96,7 +128,12 @@ class Chain extends Explorer {
     this.height = this.blocks.length;
   };
 
-  get_latest_block = () => this.blocks.slice(-1)[0];
+  get_latest_block = () => {
+    let blk = this.blocks.slice(-1)[0];
+    blk = this.build_block(blk);
+
+    return blk;
+  };
 
   stringify = (str) => {
     let obj = {};
@@ -106,11 +143,16 @@ class Chain extends Explorer {
     obj.parent = this.parent.path;
     obj.account = this.parent.account.name;
     obj.name = this.name;
-    obj.connections = this.connections.map(
-      (b) => new Object({ chain: b.chain.hash, block: b.hash })
+    obj.connections = this.connections.map((b) =>
+      b.stringify
+        ? new Object({
+            chain: b.chain.hash,
+            block: { hash: b.hash, _id: b._id },
+          })
+        : b
     );
     obj.hash = this.hash;
-    obj.blocks = this.blocks.map((blk) => blk.hash);
+    obj.blocks = this.blocks.map((blk) => blk.hash || blk);
 
     return str ? JSON.stringify(obj) : obj;
   };

package/Objects/Filesystem.js

@@ -64,7 +64,7 @@ class Filesystem {
 
     addr = `${chain.path}/${hash(JSON.stringify(obj))}`;
     this;
-    if (obj != null) this.manager.oracle.write(addr, obj, this.account);
+    if (obj != null) this.manager.oracle.write(addr, obj);
 
     this.manager.oracle.set(addr, { obj, type });
 

package/Objects/Manager.js

@@ -20,6 +20,8 @@ class Manager {
         let track = this.tracks[account];
         let program = track.slice(-1)[0];
 
+        if (program.hold) continue;
+
         let instruction = program.sequence[program.pointer];
 
         program.account.vm.execute(instruction, program);

package/Objects/Opcodes.js

@@ -1,5 +1,4 @@
 import { obj } from "../framer";
-import { transpile_object } from "../utils/functions";
 
 class Opcodes {
   constructor() {
@@ -30,7 +29,11 @@ class Opcodes {
   };
 
   stdin = (object, cb) => {
-    if (object == null) return;
+    if (object == null) {
+      this.flags.void = true;
+      return;
+    }
+    this.flags.void = false;
 
     this.flags.zero = !object;
     if (typeof object === "number") this.flags.neg = object < 0;

package/Objects/Oracle.js

@@ -3,14 +3,22 @@ import GDS from "generalised-datastore";
 import { hash } from "../utils/hash";
 
 class Oracle {
-  constructor(mgr) {
+  constructor(mgr, meta) {
+    meta = meta || {};
+
+    this.compression = meta.compression;
     this.fs = fs;
     this.mgr = mgr;
     this.datapaths = new Object();
-    this.gds = new GDS(process.env.DATASTORE || "godprotocol").sync();
+    this.gds = new GDS(process.env.DATASTORE || "godprotocol").sync({
+      manager: this.mgr,
+    });
   }
 
-  get_folder = (physical_address) => {
+  get_folder = (physical_address, options) => {
+    if (typeof options !== "object") {
+      options = { no_new: options ? false : true };
+    }
     return this.gds.folder(this.hash(physical_address));
   };
 
@@ -28,7 +36,7 @@ class Oracle {
       try {
         obj = this.fs.readFileSync(path);
         obj = JSON.parse(obj).data;
-        let type = typeof obj.data;
+        let type = obj && obj.data && typeof obj.data;
         type =
           type === "object" ? (Array.isArray(obj) ? "array" : "twain") : type;
 
@@ -45,32 +53,76 @@ class Oracle {
     return hash(data);
   };
 
-  write = (addr, data) => {
-    data = JSON.stringify({ data });
+  handle_compression = ({ addr, data, no_string }) => {
+    if (this.compression) {
+      let res = this.compression({ addr, data, no_string });
+      if (res) data = res.data;
+    }
+    if (!no_string && (typeof addr !== "string" || typeof data !== "string"))
+      return;
+
+    return data;
+  };
+
+  write = (address, payload) => {
+    payload = JSON.stringify({ payload });
+    let data = this.handle_compression({
+      addr: address,
+      data: payload,
+    });
 
-    this.fs.writeFileSync(addr, data, { encoding: "utf-8" });
+    this.fs.writeFileSync(address, data, { encoding: "utf-8" });
   };
 
-  fetch = (payload, callback) => {
-    let { physical_address, query, account, signature } = payload,
+  fetch = (payload, callback, val_err_cb) => {
+    let { physical_address, config, query, account, signature } = payload,
       result;
 
     account = this.mgr.get_account(account);
     if (account && account.private)
-      if (!account.validate({ physical_address, query }, signature, callback))
-        return;
+      if (
+        !account.validate(
+          { physical_address, account, query },
+          signature,
+          callback
+        )
+      )
+        return typeof val_err_cb === "function" && val_err_cb();
 
     try {
-      let operation = this.gds.folder(this.hash(physical_address))[
-        query.operation
-      ];
-
-      result = operation && operation(query.query, query.options);
-
-      if (result) {
-        if (account) {
-          let content = account.read(result.data);
-          if (content != null) result.content = content;
+      let folder = this.gds.folder(this.hash(physical_address));
+
+      if (config) {
+        result = folder.config;
+      } else {
+        if (!folder.check_remote(query.operation)) {
+          result = {
+            error: true,
+            error_message: "Forbidden remote operations",
+            payload,
+          };
+        } else {
+          if (query.operation === "call") {
+            let compressed_result = this.compression({ payload, val_err_cb });
+            if (compressed_result && compressed_result.halt)
+              return (
+                typeof callback === "function" &&
+                callback({ compressed: true, data: compressed_result })
+              );
+            query = (compressed_result && compressed_result.query) || query;
+          }
+
+          let operation = folder[query.operation];
+
+          result =
+            operation && operation(query.query, { ...query.options, payload });
+
+          if (result) {
+            if (account) {
+              // let content = account.read(result.data);
+              // if (content != null) result.content = content;
+            }
+          }
         }
       }
     } catch (e) {

package/Objects/Virtual_machine.js

@@ -11,6 +11,7 @@ class Virtual_machine extends Opcodes {
       neg: false,
       equal: false,
       zero: false,
+      void: false,
     };
   }
 
@@ -84,6 +85,13 @@ class Virtual_machine extends Opcodes {
         chain = context.account.add_chain(args, context);
         this.contexts.push(chain);
 
+        let dim = context.folder.config.dimensions;
+        if (!dim) {
+          dim = [];
+          context.folder.config.dimensions = dim;
+        }
+        !dim.find((d) => d === args) && dim.push(args);
+
         chain.append_buffer();
 
         break;
@@ -91,7 +99,10 @@ class Virtual_machine extends Opcodes {
         chain = context.account.manager.web.get(args);
 
         if (!chain) {
-          this.account.flush_buffer(this.track.pid);
+          this.account.flush_buffer(this.track.pid, {
+            error: true,
+            error_message: `LINKing Failed. - ${args}`,
+          });
           this.track.pointer = this.track.sequence.length;
 
           console.log(`LINKing Failed. - ${args}`);

package/opcodes.js

@@ -42,9 +42,11 @@ const opcodes = (account) => {
 
   set("stdout", stdout);
 
-  set("add_server", (args, vm) => account.add_server(args && args.op0))[
-    ("run", "load", "parse", "create_account")
-  ].map((op) =>
+  set("hold", (arg) => (vm.track.hold = !!arg.op0));
+
+  set("add_server", (args, vm) => account.add_server(args && args.op0));
+
+  [("run", "load", "parse", "create_account")].map((op) =>
     set(op, (arg) => arg && arg.op0 && account[op](arg && arg.op0))
   );
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.0.831",
+  "version": "1.0.833",
   "description": "A data mediator.",
   "main": "Index.js",
   "types": "types/index.d.ts",

package/readme.md

@@ -116,7 +116,7 @@ Type `method`
 |              | string   | `account`          | Account instance to execute the instructions in.                                                                                                                                                          |
 | `cb`         | function |                    | A function that is called with the blocks mined during the execution.                                                                                                                                     |
 
-See the [package source](https://github.com/immanuel-savvy/godprotocol.git) for more details.
+See the [package source](https://github.com/godprotocol4/GodProtocol) for more details.
 
 [npm-url]: https://npmjs.org/package/godprotocol
 [downloads-url]: https://npmjs.org/package/godprotocol

package/utils/create_server.js

@@ -7,7 +7,7 @@ let PORT = Number(process.env.PORT) || 1408;
 const cb = (res, data) => {
   if (typeof data !== "string") data = JSON.stringify(data);
 
-  res(data);
+  res.end(data);
 };
 
 let extensions = new Object();
@@ -41,7 +41,11 @@ const handle_routes = (req, res, app) => {
       try {
         data = JSON.parse(data);
       } catch (e) {
-        return cb(res.end, { error_message: "Invalid data", error: true });
+        return cb(res, {
+          error_message: "Invalid data",
+          url: req.url,
+          error: true,
+        });
       }
 
       if (req.url === "/create_account") {
@@ -50,7 +54,7 @@ const handle_routes = (req, res, app) => {
       } else if (["run", "load", "parse"].includes(req.url.slice(1))) {
         let payload = {
           ...data,
-          callback: (datagram) => cb(res.end, datagram),
+          callback: (datagram) => cb(res, datagram),
         };
         initiator.endpoint(req.url.slice(1), payload);
       } else {
@@ -64,7 +68,7 @@ const handle_routes = (req, res, app) => {
     });
 
     req.on("error", (e) => {
-      res.writeHead(500, { "Content-Type": "application/json" });
+      // res.writeHead(500, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ status: "error", message: e.message }));
     });
   } else {