From 0ff6a2e59958bce7a0c4a3c55e91c999c99da457 Mon Sep 17 00:00:00 2001 From: ram <ram> Date: Sun, 31 May 1992 02:23:44 +0000 Subject: [PATCH] Initial revision --- contrib/ops/b.ops | 181 + contrib/ops/bug.ops | 15 + contrib/ops/ceramic.ops | 348 ++ contrib/ops/compile-ops.lisp | 12 + contrib/ops/dec.ops | 299 ++ contrib/ops/fbug.ops | 3089 ++++++++++++ contrib/ops/haunt.ops | 6745 +++++++++++++++++++++++++ contrib/ops/mab.ops | 174 + contrib/ops/myw.ops | 9029 ++++++++++++++++++++++++++++++++++ contrib/ops/pp.ops | 53 + contrib/ops/rubik.ops | 2026 ++++++++ contrib/ops/test1.ops | 21 + contrib/ops/test2.ops | 74 + contrib/ops/test3.ops | 110 + contrib/ops/tourney.ops | 299 ++ contrib/ops/ttt.ops | 308 ++ contrib/ops/weaver.ops | 8850 +++++++++++++++++++++++++++++++++ 17 files changed, 31633 insertions(+) create mode 100644 contrib/ops/b.ops create mode 100644 contrib/ops/bug.ops create mode 100644 contrib/ops/ceramic.ops create mode 100644 contrib/ops/compile-ops.lisp create mode 100644 contrib/ops/dec.ops create mode 100644 contrib/ops/fbug.ops create mode 100644 contrib/ops/haunt.ops create mode 100644 contrib/ops/mab.ops create mode 100644 contrib/ops/myw.ops create mode 100644 contrib/ops/pp.ops create mode 100644 contrib/ops/rubik.ops create mode 100644 contrib/ops/test1.ops create mode 100644 contrib/ops/test2.ops create mode 100644 contrib/ops/test3.ops create mode 100644 contrib/ops/tourney.ops create mode 100644 contrib/ops/ttt.ops create mode 100644 contrib/ops/weaver.ops diff --git a/contrib/ops/b.ops b/contrib/ops/b.ops new file mode 100644 index 000000000..b774bd1d1 --- /dev/null +++ b/contrib/ops/b.ops @@ -0,0 +1,181 @@ + + +(literalize primer zero role count zero) +(literalize maker role count fin zero) +(literalize goal count zero) + + +(p run + (goal ^count <c>) + --> + (bind <z> (compute <c> + 1)) + (modify 1 ^count <z>)) + + +(p makeprimer + (maker ^count <c> ^fin > <c> ^role <r>) + --> + (make primer ^role <r> ^zero 0 ^count <c>) + (bind <z> (compute <c> + 1)) + (modify 1 ^count <z>)) + + +(p beginrun + (maker ^count <c> ^fin = <c> ^role left) + (maker ^count <d> ^fin = <d> ^role right) + --> + (remove 1) + (remove 1) + (make goal ^count 0 ^zero 0)) + + +(p start + (start) + --> + (remove 1) + (make maker ^role left ^count 1 ^fin 50) + (make maker ^role right ^count 1 ^fin 50)) + + +(p leftrule10 + (goal ^zero <c>) + (primer ^role left ^zero <> <c> ^count <> 10) + --> + (remove 1)) + + +(p leftrule9 + (goal ^zero <c>) + (primer ^role left ^zero <> <c> ^count <> 9) + --> + (remove 1)) + + +(p leftrule8 + (goal ^zero <c>) + (primer ^role left ^zero <> <c> ^count <> 8) + --> + (remove 1)) + + +(p leftrule7 + (goal ^zero <c>) + (primer ^role left ^zero <> <c> ^count <> 7) + --> + (remove 1)) + + +(p leftrule6 + (goal ^zero <c>) + (primer ^role left ^zero <> <c> ^count <> 6) + --> + (remove 1)) + + +(p leftrule5 + (goal ^zero <c>) + (primer ^role left ^zero <> <c> ^count <> 5) + --> + (remove 1)) + + +(p leftrule4 + (goal ^zero <c>) + (primer ^role left ^zero <> <c> ^count <> 4) + --> + (remove 1)) + + +(p leftrule3 + (goal ^zero <c>) + (primer ^role left ^zero <> <c> ^count <> 3) + --> + (remove 1)) + + +(p leftrule2 + (goal ^zero <c>) + (primer ^role left ^zero <> <c> ^count <> 2) + --> + (remove 1)) + + +(p leftrule1 + (goal ^zero <c>) + (primer ^role left ^zero <> <c> ^count <> 1) + --> + (remove 1)) + + + + +(p rightrule10 + (primer ^role right ^zero <c> ^count <> 10) + (goal ^zero <> <c>) + --> + (remove 1)) + + +(p rightrule9 + (primer ^role right ^zero <c> ^count <> 9) + (goal ^zero <> <c>) + --> + (remove 1)) + + +(p rightrule8 + (primer ^role right ^zero <c> ^count <> 8) + (goal ^zero <> <c>) + --> + (remove 1)) + + +(p rightrule7 + (primer ^role right ^zero <c> ^count <> 7) + (goal ^zero <> <c>) + --> + (remove 1)) + + +(p rightrule6 + (primer ^role right ^zero <c> ^count <> 6) + (goal ^zero <> <c>) + --> + (remove 1)) + + +(p rightrule5 + (primer ^role right ^zero <c> ^count <> 5) + (goal ^zero <> <c>) + --> + (remove 1)) + + +(p rightrule4 + (primer ^role right ^zero <c> ^count <> 4) + (goal ^zero <> <c>) + --> + (remove 1)) + + +(p rightrule3 + (primer ^role right ^zero <c> ^count <> 3) + (goal ^zero <> <c>) + --> + (remove 1)) + + +(p rightrule2 + (primer ^role right ^zero <c> ^count <> 2) + (goal ^zero <> <c>) + --> + (remove 1)) + + +(p rightrule1 + (primer ^role right ^zero <c> ^count <> 1) + (goal ^zero <> <c>) + --> + (remove 1)) + + diff --git a/contrib/ops/bug.ops b/contrib/ops/bug.ops new file mode 100644 index 000000000..b907f35f3 --- /dev/null +++ b/contrib/ops/bug.ops @@ -0,0 +1,15 @@ +(literalize wme val) + +(p sort + (wme ^val <x>) + - (wme ^val < <x>) + --> + (write <x> (crlf)) + (remove 1)) + +(p start + (start) + --> + (make wme ^val 0) + (make wme ^val 1) + (make wme ^val -1)) diff --git a/contrib/ops/ceramic.ops b/contrib/ops/ceramic.ops new file mode 100644 index 000000000..a49dee19b --- /dev/null +++ b/contrib/ops/ceramic.ops @@ -0,0 +1,348 @@ + + +(literalize component) (literalize context) (literalize pcon) (literalize datum) +(literalize computation) (literalize setattr) (literalize template) (literalize interaction) +(literalize lineitem) (literalize local) (literalize discrlist) (literalize task) +(literalize arg) (literalize call) (literalize order) (literalize wip) +(literalize location) (literalize input) (literalize object) (literalize x) +(literalize status) (literalize place) (literalize time) (literalize port) +(literalize module) (literalize link) (literalize lists) (literalize outnode) +(literalize operator) (literalize current) (literalize attval) (literalize choice) +(literalize applied) (literalize stateop) (literalize exit) +(literalize component0) (literalize context0) (literalize pcon0) (literalize datum0) +(literalize computation0) (literalize setattr0) (literalize template0) (literalize interaction0) +(literalize lineitem0) (literalize local0) (literalize discrlist0) (literalize task0) +(literalize arg0) (literalize call0) (literalize order0) (literalize wip0) +(literalize location0) (literalize input0) (literalize object0) (literalize x0) +(literalize status0) (literalize place0) (literalize time0) (literalize port0) +(literalize module0) (literalize link0) (literalize lists0) (literalize outnode0) +(literalize operator0) (literalize current0) (literalize attval0) (literalize choice0) +(literalize applied0) (literalize stateop0) (literalize exit0) +(literalize tank) (literalize pipe) (literalize measurement) (literalize reading) +(literalize goal) (literalize material) + +(literalize primer + spacer + role + cnt + null) + +(literalize count + spacer + role + null + val + delta + null2) + + + +(p start + (start) + --> + (remove 1) + (make primer ^role exist ^cnt 1) + (make primer ^role exist ^cnt 2) + (make primer ^role exist ^cnt 3) + (make primer ^role exist ^cnt 4) + (make primer ^role exist ^cnt 5) + (make primer ^role exist ^cnt 6) + (make primer ^role exist ^cnt 7) + (make primer ^role exist ^cnt 8) + (make primer ^role exist ^cnt 9) + (make primer ^role exist ^cnt 10) + (make primer ^role exist ^cnt 11) + (make primer ^role exist ^cnt 12) + (make primer ^role exist ^cnt 13) + (make primer ^role exist ^cnt 14) + (make primer ^role exist ^cnt 15) + (make primer ^role exist ^cnt 16) + (make primer ^role exist ^cnt 17) + (make primer ^role exist ^cnt 18) + (make primer ^role exist ^cnt 19) + (make primer ^role exist ^cnt 20) + (make primer ^role exist ^cnt 21) + (make primer ^role exist ^cnt 22) + (make primer ^role exist ^cnt 23) + (make primer ^role exist ^cnt 24) + (make primer ^role exist ^cnt 25) + (make primer ^role exist ^cnt 26) + (make primer ^role exist ^cnt 27) + (make primer ^role exist ^cnt 28) + (make primer ^role exist ^cnt 29) + (make primer ^role exist ^cnt 30) + (make count ^role exist ^val 1 ^delta 7) + (make count ^role exist ^val 2 ^delta 7) + (make count ^role exist ^val 3 ^delta 7) + (make count ^role exist ^val 4 ^delta 7) + (make count ^role exist ^val 5 ^delta 7) + (make count ^role exist ^val 6 ^delta 7) + (make count ^role exist ^val 7 ^delta 7) + (make primer ^role driver ^cnt -1)) + + + +(p driver + (primer ^role driver ^null <x>) + (count ^null <x> ^val <val> ^delta <delta>) + - (count ^val < <val>) + --> + (modify 2 ^val (compute <val> + <delta>))) + + +(p driverCopy + (primer ^role driver ^null <x>) + (count ^null <x> ^val <val> ^delta <delta>) + - (count ^val < <val>) + --> + (modify 2 ^val (compute <val> + <delta>))) + + +(p alphamem + (primer ^role nonexist) + (count) + (count) + (count) + (count) + (count) + (count) + (count) + --> + (halt)) + + +(p betamem1 + (count ^null <> betamem1) + (primer ^role nonexist) + --> + (halt)) + + +(p betamem2 + (count ^null <> betamem2) + (primer ^role nonexist) + --> + (halt)) + + +(p betamem3 + (count ^null <> betamem3) + (primer ^role exist ^cnt < 1) + --> + (halt)) + + +(p betaleft1 + (count ^null <> betamem3 ^null <n>) + (primer ^role exist ^cnt <= 25 ^role <n>) + --> + (halt)) + + +(p betaleft2 + (count ^null <> betamem3 ^null <n>) + (primer ^role exist ^cnt <= 24 ^role <n>) + --> + (halt)) + + +(p andrightnull1 + (primer ^role nonexist1) + (count) + (count) + (count) + (count) + (count) + (count) + (count) + --> + (halt)) + + +(p andrightnull2 + (primer ^role nonexist2) + (count) + (count) + (count) + (count) + --> + (halt)) + + +(p andrightloop + (primer ^role exist ^cnt <= 13 ^null <n>) + (count ^role <n>) + --> + (halt)) + + +(p notleft + (primer ^role driver ^null <x>) + (count ^null <x>) + - (primer ^role exist ^cnt <= 23 ^null <x> ^null <x>) + --> + (halt)) + + +(p notrnull1 + (primer ^role notex1) + - (count) + --> + (halt)) + + +(p notrnull2 + (primer ^role notex2) + - (count) + --> + (halt)) + + +(p notrnull3 + (primer ^role notex3) + - (count) + --> + (halt)) + + +(p notrnull4 + (primer ^role notex4) + - (count) + --> + (halt)) + + +(p notrnull5 + (primer ^role notex5) + - (count) + --> + (halt)) + + +(p notrnull6 + (primer ^role notex6) + - (count) + --> + (halt)) + + +(p notright + (primer ^role exist ^cnt <= 8 ^null <x>) + - (count ^null <x> ^null2 <x>) + --> + (halt)) + + +(p object12 + (component) (context) (pcon) (datum) + (computation) (setattr) (template) (interaction) + (lineitem) (local) (discrlist) (task) + --> + (halt)) + +(p object24 + (arg) (call) (order) (wip) + (location) (input) (object) (x) + (status) (place) (time) (port) + --> + (halt)) + +(p object36 + (module) (link) (lists) (outnode) + (operator) (current) (attval) (choice) + (operator) (applied) (stateop) (exit) + --> + (halt)) + + +(p object48 + (component0) (context0) (pcon0) (datum0) + (computation0) (setattr0) (template0) (interaction0) + (lineitem0) (local0) (discrlist0) (task0) + --> + (halt)) + +(p object60 + (arg0) (call0) (order0) (wip0) + (location0) (input0) (object0) (x0) + (status0) (place0) (time0) (port0) + --> + (halt)) + +(p object72 + (module0) (link0) (lists0) (outnode0) + (operator0) (current0) (attval0) (choice0) + (operator0) (applied0) (stateop0) (exit0) + --> + (halt)) + +(p object78 + (tank) (pipe) (measurement) (reading) + (goal) (material) + --> + (halt)) + + +(p tnea0 + (count ^null a) + (count ^null b) + (count ^null c) + (count ^null d) + (count ^null e) + (count ^null f) + (count ^null g) + (count ^null h) + (count ^null i) + (count ^null j) + --> + (halt)) + +(p tnea1 + (count ^null a1) + (count ^null b1) + (count ^null c1) + (count ^null d1) + (count ^null e1) + (count ^null f1) + (count ^null g1) + (count ^null h1) + (count ^null i1) + (count ^null j1) + --> + (halt)) + +(p tnea2 + (count ^null a2) + (count ^null b2) + (count ^null c2) + (count ^null d2) + (count ^null e2) + (count ^null f2) + (count ^null g2) + (count ^null h2) + (count ^null i2) + (count ^null j2) + --> + (halt)) + +(p tnea3 + (count ^null a3) + (count ^null b3) + (count ^null c3) + (count ^null d3) + (count ^null e3) + (count ^null f3) + (count ^null g3) + --> + (halt)) + + +(p cs + (primer ^role exist ^cnt <= 2) + (primer ^role exist ^cnt <= 2) + (primer ^role exist ^cnt <= 2) + (primer ^role exist ^cnt <= 1) + (primer ^role exist ^cnt <= 1) + (primer ^role exist ^cnt <= 1) + --> + (halt)) diff --git a/contrib/ops/compile-ops.lisp b/contrib/ops/compile-ops.lisp new file mode 100644 index 000000000..e4ef985dd --- /dev/null +++ b/contrib/ops/compile-ops.lisp @@ -0,0 +1,12 @@ +(unless (find-package "OPS") (make-package "OPS")) + +(compile-file + '("library:contrib/ops/ops-util.lisp" + "library:contrib/ops/ops-compile.lisp" + "library:contrib/ops/ops-rhs.lisp" + "library:contrib/ops/ops-match.lisp" + "library:contrib/ops/ops-main.lisp" + "library:contrib/ops/ops-backup.lisp" + "library:contrib/ops/ops-io.lisp" + "library:contrib/ops/ops.lisp") + :output-file "library:contrib/ops/ops.fasl") diff --git a/contrib/ops/dec.ops b/contrib/ops/dec.ops new file mode 100644 index 000000000..de2b04a6c --- /dev/null +++ b/contrib/ops/dec.ops @@ -0,0 +1,299 @@ + +(literalize player + number + nights-scheduled) + +(literalize foursome + night + group + north + south + east + west) + +(literalize context + name) + +(literalize scheduling + night) + +(literalize already-played + player1 + player2) + +(literalize candidate + group + chosen + south + east + west) + + +(p startup + (start) +--> + (make player ^number 1 ^nights-scheduled 0) + (make player ^number 2 ^nights-scheduled 0) + (make player ^number 3 ^nights-scheduled 0) + (make player ^number 4 ^nights-scheduled 0) + (make player ^number 5 ^nights-scheduled 0) + (make player ^number 6 ^nights-scheduled 0) + (make player ^number 7 ^nights-scheduled 0) + (make player ^number 8 ^nights-scheduled 0) + (make player ^number 9 ^nights-scheduled 0) + (make player ^number 10 ^nights-scheduled 0) + (make player ^number 11 ^nights-scheduled 0) + (make player ^number 12 ^nights-scheduled 0) + (make player ^number 13 ^nights-scheduled 0) + (make player ^number 14 ^nights-scheduled 0) + (make player ^number 15 ^nights-scheduled 0) + (make player ^number 16 ^nights-scheduled 0) + (make foursome ^night 1 ^group a ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 1 ^group b ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 1 ^group c ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 1 ^group d ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 2 ^group a ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 2 ^group b ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 2 ^group c ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 2 ^group d ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 3 ^group a ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 3 ^group b ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 3 ^group c ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 3 ^group d ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 4 ^group a ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 4 ^group b ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 4 ^group c ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 4 ^group d ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 5 ^group a ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 5 ^group b ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 5 ^group c ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 5 ^group d ^north nil ^south nil ^east nil ^west nil) + (make context ^name north) + (make scheduling ^night 1) + (write (tabto 32) |Tournament Schedule| (crlf) (crlf) + (tabto 15) |N S E W| + (tabto 42) |N S E W| + (tabto 68) |N S E W| (crlf) + (tabto 15) |= = = =| + (tabto 42) |= = = =| + (tabto 68) |= = = =| (crlf))) + +(p north:pick-one-1 + (context ^name north) + (scheduling ^night <n>) + { <THE-FOURSOME> (foursome ^night <n> ^north nil) } + { <THE-PLAYER> (player ^number <p> ^nights-scheduled < <n>) } + (foursome ^night <n> ^north { <p1> <> nil }) + (foursome ^night <n> ^north { <p2> <> <p1> <> nil }) + (foursome ^night <n> ^north { <p3> <> <p2> <> <p1> <> nil }) + (already-played ^player1 <p> ^player2 <p1>) + (already-played ^player1 <p> ^player2 <p2>) + (already-played ^player1 <p> ^player2 <p3>) +--> + (modify <THE-PLAYER> ^nights-scheduled <n>) + (modify <THE-FOURSOME> ^north <p>) ) + +(p north:pick-one-2 + (context ^name north) + (scheduling ^night <n>) + { <THE-FOURSOME> (foursome ^night <n> ^north nil) } + { <THE-PLAYER> (player ^number <p> ^nights-scheduled < <n>) } + (foursome ^night <n> ^north { <p1> <> nil }) + (foursome ^night <n> ^north { <p2> <> <p1> <> nil }) + (already-played ^player1 <p> ^player2 <p1>) + (already-played ^player1 <p> ^player2 <p2>) +--> + (modify <THE-PLAYER> ^nights-scheduled <n>) + (modify <THE-FOURSOME> ^north <p>) ) + +(p north:pick-one-3 + (context ^name north) + (scheduling ^night <n>) + { <THE-FOURSOME> (foursome ^night <n> ^north nil) } + { <THE-PLAYER> (player ^number <p> ^nights-scheduled < <n>) } + (foursome ^night <n> ^north { <p1> <> nil }) + (already-played ^player1 <p> ^player2 <p1>) +--> + (modify <THE-PLAYER> ^nights-scheduled <n>) + (modify <THE-FOURSOME> ^north <p>) ) + +(p north:pick-one-4 + (context ^name north) + (scheduling ^night <n>) + { <THE-FOURSOME> (foursome ^night <n> ^north nil) } + { <THE-PLAYER> (player ^number <p> ^nights-scheduled < <n>) } +--> + (modify <THE-PLAYER> ^nights-scheduled <n>) + (modify <THE-FOURSOME> ^north <p>) ) + +(p north:done + { <THE-CONTEXT> (context ^name north) } +--> + (modify <THE-CONTEXT> ^name make-candidates)) + +(p make-candidates:make-candidate + (context ^name make-candidates) + (scheduling ^night { <n> < 3 }) + (foursome ^night <n> ^group <g> ^north <yankee>) + (player ^number <redneck> ^nights-scheduled < <n>) + (player ^number { <oriental> < <redneck> } ^nights-scheduled < <n>) + (player ^number { <cowboy> < <oriental> } ^nights-scheduled < <n>) + - (already-played ^player1 <yankee> ^player2 <redneck>) + - (already-played ^player1 <yankee> ^player2 <oriental>) + - (already-played ^player1 <yankee> ^player2 <cowboy>) + - (already-played ^player1 <redneck> ^player2 <oriental>) + - (already-played ^player1 <redneck> ^player2 <cowboy>) + - (already-played ^player1 <oriental> ^player2 <cowboy>) + - (candidate ^group <g> ^chosen no ^south <redneck> ^east <oriental>) + - (candidate ^group <g> ^chosen no ^south <redneck> ^west <cowboy>) + - (candidate ^group <g> ^chosen no ^east <oriental> ^west <cowboy>) +--> + (make candidate ^group <g> ^chosen no + ^south <redneck> ^east <oriental> ^west <cowboy>)) + +(p make-candidates:make-candidate-late + (context ^name make-candidates) + (scheduling ^night { <n> > 2 }) + (foursome ^night <n> ^group <g> ^north <yankee>) + (player ^number <redneck> ^nights-scheduled < <n>) + (player ^number { <oriental> < <redneck> } ^nights-scheduled < <n>) + (player ^number { <cowboy> < <oriental> } ^nights-scheduled < <n>) + - (already-played ^player1 <yankee> ^player2 <redneck>) + - (already-played ^player1 <yankee> ^player2 <oriental>) + - (already-played ^player1 <yankee> ^player2 <cowboy>) + - (already-played ^player1 <redneck> ^player2 <oriental>) + - (already-played ^player1 <redneck> ^player2 <cowboy>) + - (already-played ^player1 <oriental> ^player2 <cowboy>) +--> + (make candidate ^group <g> ^chosen no + ^south <redneck> ^east <oriental> ^west <cowboy>)) + +(p make-candidates:done + { <THE-CONTEXT> (context ^name make-candidates) } +--> + (modify <THE-CONTEXT> ^name make-choice)) + +(p make-choice:doit + { <THE-CONTEXT> (context ^name make-choice) } + { <WINNER-A> (candidate ^group a ^chosen no + ^south <sa> + ^east <ea> + ^west <wa>) } + { <WINNER-B> (candidate ^group b ^chosen no + ^south { <sb> <> <sa> <> <ea> <> <wa> } + ^east { <eb> <> <sa> <> <ea> <> <wa> } + ^west { <wb> <> <sa> <> <ea> <> <wa> }) } + { <WINNER-C> (candidate ^group c ^chosen no + ^south { <sc> <> <sa> <> <ea> <> <wa> <> <sb> <> <eb> <> <wb> } + ^east { <ec> <> <sa> <> <ea> <> <wa> <> <sb> <> <eb> <> <wb> } + ^west { <wc> <> <sa> <> <ea> <> <wa> <> <sb> <> <eb> <> <wb> }) } + { <WINNER-D> (candidate ^group d ^chosen no + ^south { <sd> + <> <sa> <> <ea> <> <wa> + <> <sb> <> <eb> <> <wb> + <> <sc> <> <ec> <> <wc> } + ^east { <ed> + <> <sa> <> <ea> <> <wa> + <> <sb> <> <eb> <> <wb> + <> <sc> <> <ec> <> <wc> } + ^west { <wd> + <> <sa> <> <ea> <> <wa> + <> <sb> <> <eb> <> <wb> + <> <sc> <> <ec> <> <wc> }) } +--> + (modify <WINNER-A> ^chosen yes) + (modify <WINNER-B> ^chosen yes) + (modify <WINNER-C> ^chosen yes) + (modify <WINNER-D> ^chosen yes) + (modify <THE-CONTEXT> ^name remove-candidates)) + +(p remove-candidates:bye + (context ^name remove-candidates) + { <THE-CANDIDATE> (candidate ^chosen no) } +--> + (remove <THE-CANDIDATE>)) + +(p remove-candidates:done + { <THE-CONTEXT> (context ^name remove-candidates) } +--> + (modify <THE-CONTEXT> ^name apply-choice)) + +(p apply-choice:doit + (context ^name apply-choice) + (scheduling ^night <n>) + { <THE-FOURSOME> (foursome ^night <n> ^group <g> ^north <yankee>) } + { <THE-CHOICE> (candidate ^group <g> ^chosen yes + ^south <redneck> ^east <oriental> ^west <cowboy>) } +--> + (modify <THE-FOURSOME> ^south <redneck> ^east <oriental> ^west <cowboy>) + (remove <THE-CHOICE>) + (make already-played ^player1 <yankee> ^player2 <redneck>) + (make already-played ^player2 <yankee> ^player1 <redneck>) + (make already-played ^player1 <yankee> ^player2 <oriental>) + (make already-played ^player2 <yankee> ^player1 <oriental>) + (make already-played ^player1 <yankee> ^player2 <cowboy>) + (make already-played ^player2 <yankee> ^player1 <cowboy>) + (make already-played ^player1 <redneck> ^player2 <oriental>) + (make already-played ^player2 <redneck> ^player1 <oriental>) + (make already-played ^player1 <redneck> ^player2 <cowboy>) + (make already-played ^player2 <redneck> ^player1 <cowboy>) + (make already-played ^player1 <oriental> ^player2 <cowboy>) + (make already-played ^player2 <oriental> ^player1 <cowboy>)) + +(p apply-choice:done + { <THE-CONTEXT> (context ^name apply-choice) } +--> + (modify <THE-CONTEXT> ^name report)) + +(p report:night-schedule + { <THE-CONTEXT> (context ^name report) } + (scheduling ^night <n>) + (foursome ^night <n> ^group a ^north <an> ^south <as> ^east <ae> ^west <aw>) + (foursome ^night <n> ^group b ^north <bn> ^south <bs> ^east <be> ^west <bw>) + (foursome ^night <n> ^group c ^north <cn> ^south <cs> ^east <ce> ^west <cw>) + (foursome ^night <n> ^group d ^north <dn> ^south <ds> ^east <de> ^west <dw>) +--> + (modify <THE-CONTEXT> ^name next-night) + (bind <n2> (compute <n> + 5)) + (bind <n3> (compute <n> + 10)) + (write (crlf) (rjust 1) |#| (rjust 1) <n> (rjust 1) : (tabto 5) + |Group A:| (rjust 3) <an> (rjust 3) <as> (rjust 3) <ae> (rjust 3) <aw> + (tabto 27) (rjust 1) |#| (rjust 2) <n2> (rjust 1) : (tabto 32) + |Group A:| (rjust 3) <an> (rjust 3) <ae> (rjust 3) <as> (rjust 3) <aw> + (tabto 53) (rjust 1) |#| (rjust 2) <n3> (rjust 1) : (tabto 58) + |Group A:| (rjust 3) <an> (rjust 3) <aw> (rjust 3) <ae> (rjust 3) <as>) + (write (crlf) + (tabto 5) + |Group B:| (rjust 3) <bn> (rjust 3) <bs> (rjust 3) <be> (rjust 3) <bw> + (tabto 32) + |Group B:| (rjust 3) <bn> (rjust 3) <be> (rjust 3) <bs> (rjust 3) <bw> + (tabto 58) + |Group B:| (rjust 3) <bn> (rjust 3) <bw> (rjust 3) <be> (rjust 3) <bs>) + (write (crlf) + (tabto 5) + |Group C:| (rjust 3) <cn> (rjust 3) <cs> (rjust 3) <ce> (rjust 3) <cw> + (tabto 32) + |Group C:| (rjust 3) <cn> (rjust 3) <ce> (rjust 3) <cs> (rjust 3) <cw> + (tabto 58) + |Group C:| (rjust 3) <cn> (rjust 3) <cw> (rjust 3) <ce> (rjust 3) <cs>) + (write (crlf) + (tabto 5) + |Group D:| (rjust 3) <dn> (rjust 3) <ds> (rjust 3) <de> (rjust 3) <dw> + (tabto 32) + |Group D:| (rjust 3) <dn> (rjust 3) <de> (rjust 3) <ds> (rjust 3) <dw> + (tabto 58) + |Group D:| (rjust 3) <dn> (rjust 3) <dw> (rjust 3) <de> (rjust 3) <ds> + (crlf))) + +(p next-night:more + { <THE-CONTEXT> (context ^name next-night) } + { <THE-NIGHT> (scheduling ^night { <n> < 5 }) } +--> + (modify <THE-CONTEXT> ^name north) + (modify <THE-NIGHT> ^night (compute <n> + 1))) + +(p next-night:done + (context ^name next-night) +--> + (write (tabto 32) |End of Scheduling| (crlf) (crlf))) + diff --git a/contrib/ops/fbug.ops b/contrib/ops/fbug.ops new file mode 100644 index 000000000..878f00525 --- /dev/null +++ b/contrib/ops/fbug.ops @@ -0,0 +1,3089 @@ + + +(literal wme-type = 1) + + + + + + + + (literal + geometry = 2 + row = 3 + column = 4 ) + + + + + + (literal + length = 3 + delta = 2 + nb = 4 + nb+d = 5 + nb+2d = 6 + nb+3d = 7 + nb+4d = 8 + nb+5d = 9 + nb+6d = 10 ) + + + + + + (literal + nb = 4 + nb-incremented = 2 ) + + + + + + (literal + value = 3 ) + + + + + + (literal + name = 5 + length = 3 + geometry = 2 + owner = 4 + position-1-state = 6 + position-2-state = 7 + position-3-state = 8 + position-4-state = 9 + position-5-state = 10 + position-6-state = 11 + position-7-state = 12 + position-1-counter-to-update = 13 + position-2-counter-to-update = 14 + position-3-counter-to-update = 15 + position-4-counter-to-update = 16 + position-5-counter-to-update = 17 + position-6-counter-to-update = 18 + position-7-counter-to-update = 19 ) + + + + + + (literal + row = 3 + column = 4 + point-of-view = 2 + name = 5 ) + + + + + + (literal + row = 3 + column = 4 + point-of-view = 2 + nb-of-compulsory-answer-creations = 5 + nb-of-fragile-winners = 6 + nb-of-strong-winners = 7 ) + + + + + + (literal + type = 2 + is-better-than-type = 3 ) + + + + + + (literal + type = 2 + state = 5 + row = 3 + column = 4 + score = 6 ) + + + + + + (literal + name = 5 + point-of-views&counters-to-add = 6 + comment = 2 ) + + + + + + (literal + type = 2 + value = 3 ) + + + + + + (literal + beginning-row = 2 + beginning-column = 3 + ending-row = 4 + ending-column = 5 ) + + + + + + (literal + state = 5 + row = 3 + column = 4 ) + + + + + + (literal + meaning = 2 + drawing-character = 3 ) + + + + + + (literal + nb-of-columns = 2 + nb-of-rows = 3 + nb-of-columns-incr = 4 + nb-of-rows-incr = 5 + max-board-size = 6 + max-board-size-incr = 7 ) + + + + + + (literal + board-row = 3 + board-column = 4 + type = 2 + line-type = 5 + previous-board-position-row = 6 + previous-board-position-column = 7 + next-board-position-row = 8 + next-board-position-column = 9 + nw-board-position-row = 10 + nw-board-position-column = 11 + ne-board-position-row = 12 + ne-board-position-column = 13 + se-board-position-row = 14 + se-board-position-column = 15 + sw-board-position-row = 16 + sw-board-position-column = 17 ) + + + + + + (literal + of = 2 + is = 3 ) + + + + + + (literal + row = 3 + column = 4 + state = 5 + vertical-state = 2 + horizontal-state = 6 + right-bent-state = 7 + left-bent-state = 8 ) + + + + + + (literal + current-context = 2 + current-sub-context = 3 + current-player = 4 + human-score = 5 + computer-score = 6 ) + + + +(p board-analyse::segment-updating-of-length-5 + (incrementation-table ^length 5 ^delta <i> ^nb <nb1> ^nb+d <nb1+i> + ^nb+2d <nb1+2i> ^nb+3d <nb1+3i> ^nb+4d <nb1+4i>) + (incrementation-table ^length 5 ^delta <j> ^nb <nb2> ^nb+d <nb2+j> + ^nb+2d <nb2+2j> ^nb+3d <nb2+3j> ^nb+4d <nb2+4j>) + (direction ^geometry <geometry> ^row <i> ^column <j>) + (segment-type + ^length 5 ^geometry <geometry> + ^owner <owner> + ^position-1-state <position-1-state> + ^position-2-state <position-2-state> + ^position-3-state <position-3-state> + ^position-4-state <position-4-state> + ^position-5-state <position-5-state> + ^position-1-counter-to-update <position-1-counter-to-update> + ^position-2-counter-to-update <position-2-counter-to-update> + ^position-3-counter-to-update <position-3-counter-to-update> + ^position-4-counter-to-update <position-4-counter-to-update> + ^position-5-counter-to-update <position-5-counter-to-update>) + (position ^row <nb1> ^column <nb2> ^state <position-1-state>) + (position ^row <nb1+i> ^column <nb2+j> ^state <position-2-state>) + (position ^row <nb1+2i> ^column <nb2+2j> ^state <position-3-state>) + (position ^row <nb1+3i> ^column <nb2+3j> ^state <position-4-state>) + (position ^row <nb1+4i> ^column <nb2+4j> ^state <position-5-state>) +--> + (make counter-to-update + ^point-of-view <owner> + ^row <nb1> ^column <nb2> + ^name <position-1-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+i> ^column <nb2+j> + ^name <position-2-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+2i> ^column <nb2+2j> + ^name <position-3-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+3i> ^column <nb2+3j> + ^name <position-4-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+4i> ^column <nb2+4j> + ^name <position-5-counter-to-update>)) + +(p board-analyse::segment-updating-of-length-6 + (incrementation-table ^length 6 ^delta <i> ^nb <nb1> ^nb+d <nb1+i> + ^nb+2d <nb1+2i> ^nb+3d <nb1+3i> ^nb+4d <nb1+4i> ^nb+5d <nb1+5i>) + (incrementation-table ^length 6 ^delta <j> ^nb <nb2> ^nb+d <nb2+j> + ^nb+2d <nb2+2j> ^nb+3d <nb2+3j> ^nb+4d <nb2+4j> ^nb+5d <nb2+5j>) + (direction ^geometry <geometry> ^row <i> ^column <j>) + (segment-type + ^length 6 ^geometry <geometry> + ^owner <owner> + ^position-1-state <position-1-state> + ^position-2-state <position-2-state> + ^position-3-state <position-3-state> + ^position-4-state <position-4-state> + ^position-5-state <position-5-state> + ^position-6-state <position-6-state> + ^position-1-counter-to-update <position-1-counter-to-update> + ^position-2-counter-to-update <position-2-counter-to-update> + ^position-3-counter-to-update <position-3-counter-to-update> + ^position-4-counter-to-update <position-4-counter-to-update> + ^position-5-counter-to-update <position-5-counter-to-update> + ^position-6-counter-to-update <position-6-counter-to-update>) + (position ^row <nb1> ^column <nb2> ^state <position-1-state>) + (position ^row <nb1+i> ^column <nb2+j> ^state <position-2-state>) + (position ^row <nb1+2i> ^column <nb2+2j> ^state <position-3-state>) + (position ^row <nb1+3i> ^column <nb2+3j> ^state <position-4-state>) + (position ^row <nb1+4i> ^column <nb2+4j> ^state <position-5-state>) + (position ^row <nb1+5i> ^column <nb2+5j> ^state <position-6-state>) +--> + (make counter-to-update + ^point-of-view <owner> + ^row <nb1> ^column <nb2> + ^name <position-1-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+i> ^column <nb2+j> + ^name <position-2-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+2i> ^column <nb2+2j> + ^name <position-3-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+3i> ^column <nb2+3j> + ^name <position-4-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+4i> ^column <nb2+4j> + ^name <position-5-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+5i> ^column <nb2+5j> + ^name <position-6-counter-to-update>)) + +(p board-analyse::segment-updating-of-length-7 + (incrementation-table ^length 7 ^delta <i> ^nb <nb1> ^nb+d <nb1+i> + ^nb+2d <nb1+2i> ^nb+3d <nb1+3i> ^nb+4d <nb1+4i> ^nb+5d <nb1+5i> ^nb+6d <nb1+6i>) + (incrementation-table ^length 7 ^delta <j> ^nb <nb2> ^nb+d <nb2+j> + ^nb+2d <nb2+2j> ^nb+3d <nb2+3j> ^nb+4d <nb2+4j> ^nb+5d <nb2+5j> ^nb+6d <nb2+6j>) + (direction ^geometry <geometry> ^row <i> ^column <j>) + (segment-type + ^length 7 ^geometry <geometry> + ^owner <owner> + ^position-1-state <position-1-state> + ^position-2-state <position-2-state> + ^position-3-state <position-3-state> + ^position-4-state <position-4-state> + ^position-5-state <position-5-state> + ^position-6-state <position-6-state> + ^position-7-state <position-7-state> + ^position-1-counter-to-update <position-1-counter-to-update> + ^position-2-counter-to-update <position-2-counter-to-update> + ^position-3-counter-to-update <position-3-counter-to-update> + ^position-4-counter-to-update <position-4-counter-to-update> + ^position-5-counter-to-update <position-5-counter-to-update> + ^position-6-counter-to-update <position-6-counter-to-update> + ^position-7-counter-to-update <position-7-counter-to-update>) + (position ^row <nb1> ^column <nb2> ^state <position-1-state>) + (position ^row <nb1+i> ^column <nb2+j> ^state <position-2-state>) + (position ^row <nb1+2i> ^column <nb2+2j> ^state <position-3-state>) + (position ^row <nb1+3i> ^column <nb2+3j> ^state <position-4-state>) + (position ^row <nb1+4i> ^column <nb2+4j> ^state <position-5-state>) + (position ^row <nb1+5i> ^column <nb2+5j> ^state <position-6-state>) + (position ^row <nb1+6i> ^column <nb2+6j> ^state <position-7-state>) +--> + (make counter-to-update + ^point-of-view <owner> + ^row <nb1> ^column <nb2> + ^name <position-1-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+i> ^column <nb2+j> + ^name <position-2-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+2i> ^column <nb2+2j> + ^name <position-3-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+3i> ^column <nb2+3j> + ^name <position-4-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+4i> ^column <nb2+4j> + ^name <position-5-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+5i> ^column <nb2+5j> + ^name <position-6-counter-to-update>) + (make counter-to-update + ^point-of-view <owner> + ^row <nb1+6i> ^column <nb2+6j> + ^name <position-7-counter-to-update>)) + +(p board-analyse::garbage-cleaning + (game-state + ^current-context board-analyse + ^current-sub-context garbage-cleaning) + (counter-to-update) +--> + (remove 2)) + +(p board-analyse::garbage-cleaning-end + (game-state + ^current-context board-analyse + ^current-sub-context garbage-cleaning) +--> + (modify 1 ^current-sub-context counters-decrementation)) + +(p board-analyse::initialisations-for-counters-decrementation + (game-state + ^current-context board-analyse + ^current-sub-context counters-decrementation) + (new-move ^row <row> ^column <column>) + (position ^row <row> ^column <column>) + (number-to-add-while-updating-counters ^value <> -1) +--> + (modify 4 ^value -1) + (modify 3 ^row <row>)) + +(p board-analyse::counters-decrementation-end + (game-state + ^current-context board-analyse + ^current-sub-context counters-decrementation) +--> + (modify 1 ^current-sub-context counters-incrementation)) + +(p board-analyse::initialisations-for-counters-incrementation + (game-state + ^current-context board-analyse + ^current-sub-context counters-incrementation) + (new-move ^row <row> ^column <column> ^state <state>) + (position ^row <row> ^column <column>) + (number-to-add-while-updating-counters ^value <> 1) +--> + (remove 2) + (modify 4 ^value 1) + (modify 3 ^state <state>)) + +(p board-analyse::counters-incrementation-end + (game-state + ^current-context board-analyse + ^current-sub-context counters-incrementation) + (number-to-add-while-updating-counters) +--> + (modify 2 ^value ignore-it) + (modify 1 ^current-context choice-of-a-move + ^current-sub-context choice-of-segments)) + + +(p board-analyse::counter-updating + (game-state ^current-context board-analyse) + (counter-to-update + ^name {<name> <> garbage} + ^row <row> + ^column <column> + ^point-of-view <point-of-view>) + (number-to-add-while-updating-counters + ^value {<increment-value> <> ignore-it}) + (position-analyse + ^row <row> + ^column <column> + ^point-of-view <point-of-view>) + (position + ^row <row> + ^column <column> + ^state vacant) +--> + (bind <counter-value> (substr 4 <name> <name>)) + (modify 4 ^<name> (compute <increment-value> + <counter-value>)) + (remove 2)) + +(p board-analyse::making-of-two-position-analyses + (game-state ^current-context board-analyse) + (counter-to-update + ^name {<name> <> garbage} + ^row <row> + ^column <column>) + (number-to-add-while-updating-counters + ^value <> ignore-it) + -(position-analyse + ^row <row> + ^column <column>) + (position + ^row <row> + ^column <column> + ^state vacant) + +--> + (make position-analyse + ^row <row> ^column <column> + ^point-of-view human + ^nb-of-compulsory-answer-creations 0 + ^nb-of-fragile-winners 0 + ^nb-of-strong-winners 0) + (make position-analyse + ^row <row> ^column <column> + ^point-of-view computer + ^nb-of-compulsory-answer-creations 0 + ^nb-of-fragile-winners 0 + ^nb-of-strong-winners 0)) + +(p board-analyse::removal-of-a-pointless-position-analyse + (game-state ^current-context board-analyse) + (number-to-add-while-updating-counters + ^value {<increment-value> <> ignore-it}) + (position-analyse + ^row <row> + ^column <column>) + (position + ^row <row> + ^column <column> + ^state <> vacant) +--> + (remove 3)) + + +(p board-analyse::removal-of-a-pointless-counter-updating + (counter-to-update + ^name garbage) +--> + (remove 1)) + + + + + +(p choice-of-a-move-by-the-computer::compulsory-answers-computation + (game-state + ^current-context choice-of-a-move + ^current-sub-context generation-of-the-best-possible-moves + ^current-player computer) + (position-analyse + ^point-of-view computer + ^row <row> + ^column <column> + ^nb-of-compulsory-answer-creations <nbcacc>) + (position-analyse + ^point-of-view human + ^row <row> + ^column <column> + ^nb-of-strong-winners <nbswh>) +--> + (make possible-move + ^state non-validated-nb-of-compulsory-answer-creations + ^row <row> + ^column <column> + ^score (compute <nbcacc> + <nbswh>))) + +(p choice-of-a-move-by-the-computer::compulsory-answers-validation + (game-state + ^current-context choice-of-a-move + ^current-sub-context generation-of-the-best-possible-moves + ^current-player computer) + {(possible-move + ^state non-validated-nb-of-compulsory-answer-creations + ^row <row> + ^column <column> + ^score {<score> >= 2 }) <possible-move>} +--> + (modify <possible-move> + ^state validated-nb-of-compulsory-answer-creations)) + +(p choice-of-a-move-by-the-computer::compulsory-answers-validation-to-0 + (game-state + ^current-context choice-of-a-move + ^current-sub-context generation-of-the-best-possible-moves + ^current-player computer) + {(possible-move + ^state non-validated-nb-of-compulsory-answer-creations + ^row <row> + ^column <column> + ^score {<score> < 2 }) <possible-move>} +--> + (modify <possible-move> + ^score 0 + ^state validated-nb-of-compulsory-answer-creations)) + +(p choice-of-a-move-by-the-computer::score-computation + (game-state + ^current-context choice-of-a-move + ^current-sub-context generation-of-the-best-possible-moves + ^current-player computer) + {(possible-move + ^state validated-nb-of-compulsory-answer-creations + ^row <row> + ^column <column> + ^score <score>) <possible-move>} + (position-analyse + ^point-of-view computer + ^row <row> + ^column <column> + ^nb-of-fragile-winners <nbfwc> + ^nb-of-strong-winners <nbswc>) + (position-analyse + ^point-of-view human + ^row <row> + ^column <column> + ^nb-of-fragile-winners <nbfwh> + ^nb-of-compulsory-answer-creations <nbcach>) +--> + (modify <possible-move> + ^state computed + ^score (compute (100 * (<nbfwh> + <nbfwc>)) + + (10 * <score>) + + <nbcach> + (2 * <nbswc>)))) + + +(p choice-of-a-move-by-the-computer::selection-of-the-best-moves + (game-state + ^current-context choice-of-a-move + ^current-sub-context generation-of-the-best-possible-moves + ^current-player computer) + {(possible-move + ^state computed + ^score <score-i>) <possible-move-i>} + (possible-move + ^state computed + ^score > <score-i>) +--> + (remove <possible-move-i>)) + +(p choice-of-a-move-by-the-computer::generation-of-the-best-possible-moves-end + (game-state + ^current-context choice-of-a-move + ^current-sub-context generation-of-the-best-possible-moves + ^current-player computer) +--> + (modify 1 + ^current-sub-context choice-of-the-move)) + +(p choice-of-a-move-by-the-computer::removal-of-all-possible-moves + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-the-move + ^current-player computer) + (possible-move + ^row <row> + ^column <column>) + (new-move) +--> + (remove 2)) + +(p choice-of-a-move-by-the-computer::blind-pick-up-of-one-of-the-best + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-the-move + ^current-player computer) + (possible-move + ^row <row> + ^column <column>) + -(new-move) +--> + (make last-computer-move <row> <column>) + (make new-move + ^state computer + ^row <row> + ^column <column>)) + +(p choice-of-a-move-by-the-computer::blind-pick-up-of-a-vacant-position + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-the-move + ^current-player computer) + -(possible-move) + -(new-move) + (position ^state << human computer >>) + (position + ^state vacant + ^row <row> + ^column <column>) +--> + (make last-computer-move <row> <column>) + (make new-move + ^state computer + ^row <row> + ^column <column>)) + +(p choice-of-a-move-by-the-computer::first-move + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-the-move + ^current-player computer) + -(position ^state << computer human >>) +--> + (make last-computer-move 6 5) + (make new-move + ^state computer + ^row 6 + ^column 5)) + +(p choice-of-a-move-by-the-computer::end-of-the-choice-of-the-move + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-the-move + ^current-player computer) +--> + (modify 1 ^current-context board-analyse + ^current-sub-context garbage-cleaning)) + +(p choice-of-a-move-by-the-computer::vertical-segment-choice + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^computer-score <computer-score> + ^current-player computer) + (incrementation-table ^length 4 ^delta 1 ^nb <nb1> ^nb+d <nb1+i> + ^nb+2d <nb1+2i> ^nb+3d <nb1+3i>) + (incrementation-table ^length 4 ^delta 0 ^nb <nb2> ^nb+d <nb2+j> + ^nb+2d <nb2+2j> ^nb+3d <nb2+3j>) + (position ^row <nb1> ^column <nb2> + ^state computer ^vertical-state << free end-of-a-segment >>) + (position ^row <nb1+i> ^column <nb2+j> + ^state computer ^vertical-state << free end-of-a-segment >>) + (position ^row <nb1+2i> ^column <nb2+2j> + ^state computer ^vertical-state << free end-of-a-segment >>) + (position ^row <nb1+3i> ^column <nb2+3j> + ^state computer ^vertical-state << free end-of-a-segment >>) +--> + (modify 1 ^computer-score (compute <computer-score> + 1)) + (modify 4 ^vertical-state end-of-a-segment) + (modify 5 ^vertical-state inside-a-segment) + (modify 6 ^vertical-state inside-a-segment) + (modify 7 ^vertical-state end-of-a-segment)) + +(p choice-of-a-move-by-the-computer::horizontal-segment-choice + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^computer-score <computer-score> + ^current-player computer) + (incrementation-table ^length 4 ^delta 0 ^nb <nb1> ^nb+d <nb1+i> + ^nb+2d <nb1+2i> ^nb+3d <nb1+3i>) + (incrementation-table ^length 4 ^delta 1 ^nb <nb2> ^nb+d <nb2+j> + ^nb+2d <nb2+2j> ^nb+3d <nb2+3j>) + (position ^row <nb1> ^column <nb2> + ^state computer ^horizontal-state << free end-of-a-segment >>) + (position ^row <nb1+i> ^column <nb2+j> + ^state computer ^horizontal-state << free end-of-a-segment >>) + (position ^row <nb1+2i> ^column <nb2+2j> + ^state computer ^horizontal-state << free end-of-a-segment >>) + (position ^row <nb1+3i> ^column <nb2+3j> + ^state computer ^horizontal-state << free end-of-a-segment >>) +--> + (modify 1 ^computer-score (compute <computer-score> + 1)) + (modify 4 ^horizontal-state end-of-a-segment) + (modify 5 ^horizontal-state inside-a-segment) + (modify 6 ^horizontal-state inside-a-segment) + (modify 7 ^horizontal-state end-of-a-segment)) + +(p choice-of-a-move-by-the-computer::right-bent-segment-choice + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^computer-score <computer-score> + ^current-player computer) + (incrementation-table ^length 4 ^delta -1 ^nb <nb1> ^nb+d <nb1+i> + ^nb+2d <nb1+2i> ^nb+3d <nb1+3i>) + (incrementation-table ^length 4 ^delta 1 ^nb <nb2> ^nb+d <nb2+j> + ^nb+2d <nb2+2j> ^nb+3d <nb2+3j>) + (position ^row <nb1> ^column <nb2> + ^state computer ^right-bent-state << free end-of-a-segment >>) + (position ^row <nb1+i> ^column <nb2+j> + ^state computer ^right-bent-state << free end-of-a-segment >>) + (position ^row <nb1+2i> ^column <nb2+2j> + ^state computer ^right-bent-state << free end-of-a-segment >>) + (position ^row <nb1+3i> ^column <nb2+3j> + ^state computer ^right-bent-state << free end-of-a-segment >>) +--> + (modify 1 ^computer-score (compute <computer-score> + 1)) + (modify 4 ^right-bent-state end-of-a-segment) + (modify 5 ^right-bent-state inside-a-segment) + (modify 6 ^right-bent-state inside-a-segment) + (modify 7 ^right-bent-state end-of-a-segment)) + +(p choice-of-a-move-by-the-computer::left-bent-segment-choice + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^computer-score <computer-score> + ^current-player computer) + (incrementation-table ^length 4 ^delta 1 ^nb <nb1> ^nb+d <nb1+i> + ^nb+2d <nb1+2i> ^nb+3d <nb1+3i>) + (incrementation-table ^length 4 ^delta 1 ^nb <nb2> ^nb+d <nb2+j> + ^nb+2d <nb2+2j> ^nb+3d <nb2+3j>) + (position ^row <nb1> ^column <nb2> + ^state computer ^left-bent-state << free end-of-a-segment >>) + (position ^row <nb1+i> ^column <nb2+j> + ^state computer ^left-bent-state << free end-of-a-segment >>) + (position ^row <nb1+2i> ^column <nb2+2j> + ^state computer ^left-bent-state << free end-of-a-segment >>) + (position ^row <nb1+3i> ^column <nb2+3j> + ^state computer ^left-bent-state << free end-of-a-segment >>) +--> + (modify 1 ^computer-score (compute <computer-score> + 1)) + (modify 4 ^left-bent-state end-of-a-segment) + (modify 5 ^left-bent-state inside-a-segment) + (modify 6 ^left-bent-state inside-a-segment) + (modify 7 ^left-bent-state end-of-a-segment)) + +(p choice-of-a-move-by-the-computer::end-of-choice-of-segments + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^computer-score <computer-score> + ^current-player computer) +--> + (modify 1 + ^current-context board-drawing + ^current-player human)) + + + + + + + + +(p generation-of-incrementation + (game-state ^current-context initialisations) + (board-parameters + ^max-board-size-incr <mbs+1>) + (incrementation + ^nb <nb> + ^nb-incremented {<nb-incremented> < <mbs+1>}) + -(incrementation + ^nb <nb-incremented>) +--> + (make incrementation + ^nb <nb-incremented> + ^nb-incremented (compute <nb-incremented> + 1))) + + +(p generation-of-incrementation-table + (game-state ^current-context initialisations) + (delta <delta>) + (nb <nb>) + (length <length>) +--> + (make incrementation-table + ^length <length> + ^delta <delta> + ^nb <nb> + ^nb+d (compute <nb> + <delta>) + ^nb+2d (compute <nb> + ( 2 * <delta>)) + ^nb+3d (compute <nb> + ( 3 * <delta>)) + ^nb+4d (compute <nb> + ( 4 * <delta>)) + ^nb+5d (compute <nb> + ( 5 * <delta>)) + ^nb+6d (compute <nb> + ( 6 * <delta>)))) + +(p cleaning-of-superfluous-incrementation-tables-2 + (game-state ^current-context initialisations) + (board-parameters + ^max-board-size-incr <mbs+1>) + {(incrementation-table ^length 7 ^nb+6d > <mbs+1>) + <incrementation-table>} +--> + (remove <incrementation-table>)) + +(p cleaning-of-superfluous-incrementation-tables-3 + (game-state ^current-context initialisations) + (board-parameters + ^max-board-size-incr <mbs+1>) + {(incrementation-table ^length 6 ^nb+5d > <mbs+1>) + <incrementation-table>} +--> + (remove <incrementation-table>)) + +(p cleaning-of-superfluous-incrementation-tables-4 + (game-state ^current-context initialisations) + (board-parameters + ^max-board-size-incr <mbs+1>) + {(incrementation-table ^length 5 ^nb+4d > <mbs+1>) + <incrementation-table>} +--> + (remove <incrementation-table>)) + +(p cleaning-of-superfluous-incrementation-tables-5 + (game-state ^current-context initialisations) + (board-parameters + ^max-board-size <mbs>) + {(incrementation-table ^length 4 ^nb+3d > <mbs>) + <incrementation-table>} +--> + (remove <incrementation-table>)) + +(p cleaning-of-superfluous-incrementation-tables-2-bis + (game-state ^current-context initialisations) + {(incrementation-table ^length 7 ^nb+6d < 0) + <incrementation-table>} +--> + (remove <incrementation-table>)) + +(p cleaning-of-superfluous-incrementation-tables-3-bis + (game-state ^current-context initialisations) + {(incrementation-table ^length 6 ^nb+5d < 0) + <incrementation-table>} +--> + (remove <incrementation-table>)) + +(p cleaning-of-superfluous-incrementation-tables-4-bis + (game-state ^current-context initialisations) + {(incrementation-table ^length 5 ^nb+4d < 0) + <incrementation-table>} +--> + (remove <incrementation-table>)) + +(p cleaning-of-superfluous-incrementation-tables-5-bis + (game-state ^current-context initialisations) + {(incrementation-table ^length 4 ^nb+3d <= 0) + <incrementation-table>} +--> + (remove <incrementation-table>)) + +(p generation-of-an-edge-horizontally + (game-state ^current-context initialisations) + (board-parameters + ^nb-of-columns <nbbc>) + (position + ^row {<< 0 11 >> <existing-position-row>} + ^column {<= <nbbc> <existing-position-column>}) + (incrementation + ^nb <existing-position-column> + ^nb-incremented <existing-position-column-incremented>) + -(position + ^row <existing-position-row> + ^column <existing-position-column-incremented>) +--> + (make position + ^row <existing-position-row> + ^column <existing-position-column-incremented> + ^state edge + ^vertical-state nil + ^horizontal-state nil + ^right-bent-state nil + ^left-bent-state nil)) + +(p generation-of-an-edge-vertically + (game-state ^current-context initialisations) + (board-parameters + ^nb-of-rows <nbbr>) + (position + ^column {<< 0 11 >> <existing-position-column>} + ^row {<= <nbbr> <existing-position-row>}) + (incrementation + ^nb <existing-position-row> + ^nb-incremented <existing-position-row-incremented>) + -(position + ^column <existing-position-column> + ^row <existing-position-row-incremented>) +--> + (make position + ^column <existing-position-column> + ^row <existing-position-row-incremented> + ^state edge + ^vertical-state nil + ^horizontal-state nil + ^right-bent-state nil + ^left-bent-state nil)) + +(p generation-of-an-empty-board-horizontally + (game-state ^current-context initialisations) + (board-parameters + ^nb-of-rows <nbbr> + ^nb-of-columns <nbbc>) + (position + ^row {<existing-position-row> > 0 <= <nbbr>} + ^column {< <nbbc> <existing-position-column>}) + (incrementation + ^nb <existing-position-column> + ^nb-incremented <existing-position-column-incremented>) + -(position + ^row <existing-position-row> + ^column <existing-position-column-incremented>) +--> + (make position + ^row <existing-position-row> + ^column <existing-position-column-incremented> + ^state vacant + ^vertical-state free + ^horizontal-state free + ^right-bent-state free + ^left-bent-state free)) + +(p generation-of-an-empty-board-vertically + (game-state ^current-context initialisations) + (board-parameters + ^nb-of-rows <nbbr> + ^nb-of-columns <nbbc>) + (position + ^column {<existing-position-column> > 0 <= <nbbc>} + ^row {< <nbbr> <existing-position-row>}) + (incrementation + ^nb <existing-position-row> + ^nb-incremented <existing-position-row-incremented>) + -(position + ^column <existing-position-column> + ^row <existing-position-row-incremented>) +--> + (make position + ^column <existing-position-column> + ^row <existing-position-row-incremented> + ^state vacant + ^vertical-state free + ^horizontal-state free + ^right-bent-state free + ^left-bent-state free)) + +(p determination-of-the-player-who-is-going-to-start + {<game-state> + (game-state + ^current-context initialisations + ^current-player {<> human <> computer})} + (symbol + ^meaning human + ^drawing-character <human-drawing-character>) + (symbol + ^meaning computer + ^drawing-character <computer-drawing-character>) + (board-parameters + ^nb-of-columns <nbbc> + ^nb-of-rows <nbbr>) +--> + (write |___________________________________________| + (crlf) + (crlf) + | The board has | <nbbc> | rows and | <nbbc> | columns.| + (crlf) + | You are | <human-drawing-character> |, I am | + <computer-drawing-character> |.| + (crlf) + | ___________________________________________| + (crlf) + (crlf) + |Do you want to start (return: yes, anything else: no)? |) + (make input ^type first-player ^value (acceptline human read))) + +(p validation-of-the-answer-1 + {<game-state> + (game-state + ^current-context initialisations)} + {(input ^type first-player ^value human) <input>} +--> + (remove <input>) + (modify <game-state> + ^current-player human + ^current-context choice-of-a-move + ^current-sub-context choice-of-the-move)) + +(p validation-of-the-answer-2 + {<game-state> + (game-state + ^current-context initialisations)} + {(input ^type first-player ^value <> human) <input>} +--> + (remove <input>) + (modify <game-state> + ^current-player computer + ^current-context choice-of-a-move + ^current-sub-context choice-of-the-move)) + + + +(p initialisations-for-board-drawing + {<game-state> + (game-state ^current-context board-drawing)} + {(last-computer-move <row> <column>) <last-computer-move>} + -(drawing-position-printed) +--> + (write (crlf) + (crlf) + |score: human | + (substr <game-state> human-score human-score) + | computer | + (substr <game-state> computer-score computer-score) + |. I just played| <row> <column> |.| + (crlf) + (crlf)) + (remove <last-computer-move>) + (make drawing-position-printed + ^type outside-board + ^line-type first-line + ^board-row nil + ^board-column 1)) + +(p drawing-of-the-first-line + (game-state ^current-context board-drawing) + (board-parameters + ^nb-of-columns <nbbc>) + {<drawing-position-printed> + (drawing-position-printed + ^line-type first-line + ^board-column {<> <nbbc> <board-column>})} + +--> + (bind <tab> (compute (2 + (<board-column> * 4)))) + (write (tabto <tab>) + <board-column>) + (modify <drawing-position-printed> + ^board-column (compute <board-column> + 1))) + +(p end-of-the-drawing-of-the-first-line + (game-state ^current-context board-drawing) + (board-parameters + ^nb-of-columns <nb-of-columns>) + {<drawing-position-printed> + (drawing-position-printed + ^line-type first-line + ^board-column <nb-of-columns>)} +--> + (bind <tab> (compute (2 + (4 * <nb-of-columns>)))) + (write (tabto <tab>) + <nb-of-columns> + (crlf) (crlf)) + (modify <drawing-position-printed> + ^board-row 1 + ^line-type board-line + ^type outside-board)) + +(p drawing-of-the-beginning-of-a-board-line + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type board-line + ^type outside-board + ^board-row <board-row>)} +--> + (write <board-row>) + (modify <drawing-position-printed> + ^type board-position + ^board-column 1 + ^previous-board-position-column 1 + ^previous-board-position-row <board-row> + ^next-board-position-column 2 + ^next-board-position-row <board-row>)) + +(p drawing-of-a-board-position + (game-state ^current-context board-drawing) + (board-parameters + ^nb-of-columns <nbbc>) + {<drawing-position-printed> + (drawing-position-printed + ^line-type board-line + ^type board-position + ^board-row <board-row> + ^board-column {<> <nbbc> <board-column>})} + (position + ^state <board-position-state> + ^row <board-row> + ^column <board-column>) + (symbol + ^meaning <board-position-state> + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute (2 + (4 * <board-column>)))) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type possibly-a-piece-of-horizontal-segment)) + +(p drawing-of-the-end-of-a-board-line + (game-state ^current-context board-drawing) + (board-parameters + ^nb-of-rows <nbbr> + ^nb-of-columns <nbbc>) + {<drawing-position-printed> + (drawing-position-printed + ^line-type board-line + ^type board-position + ^board-row {<> <nbbr> <board-row>} + ^board-column <nbbc>)} + (position + ^state <board-position-state> + ^row <board-row> + ^column <nbbc>) + (symbol + ^meaning <board-position-state> + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute (2 + (4 * <nbbc>)))) + (write (tabto <tab>) + <drawing-character> + (crlf)) + (modify <drawing-position-printed> + ^type outside-board + ^line-type intermediate-line)) + +(p drawing-of-the-end-of-the-board + {<game-state> + (game-state ^current-context board-drawing)} + (board-parameters + ^nb-of-rows <nbbr> + ^nb-of-columns <nbbc>) + {<drawing-position-printed> + (drawing-position-printed + ^line-type board-line + ^type board-position + ^board-row <nbbr> + ^board-column <nbbc>)} + (position + ^state <board-position-state> + ^row <nbbr> + ^column <nbbc>) + (symbol + ^meaning <board-position-state> + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute (2 + (4 * <nbbc>)))) + (write (tabto <tab>) + <drawing-character> + (crlf) (crlf)) + (remove <drawing-position-printed>) + (modify <game-state> + ^current-context choice-of-a-move + ^current-sub-context choice-of-the-move + ^current-player human)) + +(p drawing-of-an-horizontal-piece-of-segment-1 + + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type board-line + ^type possibly-a-piece-of-horizontal-segment + ^board-column <board-column> + ^board-row <board-row> + ^next-board-position-column <nbpc> + ^previous-board-position-column <pbpc>)} + (position + ^row <board-row> + ^column <pbpc> + ^state <> vacant + ^horizontal-state inside-a-segment) + (symbol + ^meaning piece-of-horizontal-segment + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute (2 + (4 * <board-column>) + 2))) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type board-position + ^board-column (compute <board-column> + 1) + ^previous-board-position-column <nbpc> + ^next-board-position-column (compute <nbpc> + 1))) + +(p drawing-of-an-horizontal-piece-of-segment-2 + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type board-line + ^type possibly-a-piece-of-horizontal-segment + ^board-column <board-column> + ^board-row <board-row> + ^next-board-position-column <nbpc> + ^previous-board-position-column <pbpc>)} + (position + ^row <board-row> + ^column <nbpc> + ^state <> vacant + ^horizontal-state inside-a-segment) + (symbol + ^meaning piece-of-horizontal-segment + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute (2 + (4 * <board-column>) + 2))) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type board-position + ^board-column (compute <board-column> + 1) + ^previous-board-position-column <nbpc> + ^next-board-position-column (compute <nbpc> + 1))) + + +(p non-drawing-of-an-horizontal-piece-of-segment + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type board-line + ^type possibly-a-piece-of-horizontal-segment + ^board-column <board-column> + ^board-row <board-row> + ^next-board-position-column <nbpc> + ^previous-board-position-column <pbpc>)} +--> + (modify <drawing-position-printed> + ^type board-position + ^board-column (compute <board-column> + 1) + ^previous-board-position-column <nbpc> + ^next-board-position-column (compute <nbpc> + 1))) + +(p drawing-of-the-beginning-of-an-intermediate-line + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type outside-board + ^board-row <board-row>)} +--> + (modify <drawing-position-printed> + ^type possibly-a-piece-of-vertical-segment + ^nw-board-position-row <board-row> + ^nw-board-position-column 1 + ^sw-board-position-row (compute 1 + <board-row>) + ^sw-board-position-column 1 + ^ne-board-position-row <board-row> + ^ne-board-position-column 2 + ^se-board-position-row (compute 1 + <board-row>) + ^se-board-position-column 2)) + +(p drawing-of-a-vertical-piece-of-segment-1 + (game-state ^current-context board-drawing) + (board-parameters + ^nb-of-columns <nbbc>) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-vertical-segment + ^nw-board-position-column {<> <nbbc> <board-column>} + ^nw-board-position-row <nwbpr>)} + (position + ^row <nwbpr> + ^column <board-column> + ^state <> vacant + ^vertical-state inside-a-segment) + (symbol + ^meaning piece-of-vertical-segment + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <board-column>))) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type possibly-a-piece-of-bent-segment)) + +(p drawing-of-a-vertical-piece-of-segment-2 + (game-state ^current-context board-drawing) + (board-parameters + ^nb-of-columns <nbbc>) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-vertical-segment + ^nw-board-position-column {<> <nbbc> <board-column>} + ^sw-board-position-row <swbpr>)} + (position + ^row <swbpr> + ^column <board-column> + ^state <> vacant + ^vertical-state inside-a-segment) + (symbol + ^meaning piece-of-vertical-segment + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <board-column>))) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type possibly-a-piece-of-bent-segment)) + +(p non-drawing-of-a-vertical-piece-of-segment + (game-state ^current-context board-drawing) + (board-parameters + ^nb-of-columns <nbbc>) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-vertical-segment + ^nw-board-position-column {<> <nbbc> <board-column>} + ^sw-board-position-row <swbpr>)} +--> + (modify <drawing-position-printed> + ^type possibly-a-piece-of-bent-segment)) + +(p drawing-of-a-piece-of-right-bent-segment-1 + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-bent-segment + ^nw-board-position-column <board-column> + ^board-row <board-row> + ^sw-board-position-column <swbpc> + ^nw-board-position-column <nwbpc> + ^se-board-position-column <sebpc> + ^ne-board-position-column <nebpc> + ^sw-board-position-row <swbpr>)} + (position + ^row <swbpr> + ^column <swbpc> + ^state <> vacant + ^right-bent-state inside-a-segment) + (symbol + ^meaning piece-of-right-bent-segment + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <board-column>) + 2)) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type possibly-a-piece-of-vertical-segment + ^sw-board-position-column <sebpc> + ^nw-board-position-column <nebpc> + ^se-board-position-column (compute <sebpc> + 1) + ^ne-board-position-column (compute <nebpc> + 1))) + +(p drawing-of-a-piece-of-right-bent-segment-2 + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-bent-segment + ^nw-board-position-column <board-column> + ^board-row <board-row> + ^sw-board-position-column <swbpc> + ^nw-board-position-column <nwbpc> + ^se-board-position-column <sebpc> + ^ne-board-position-column <nebpc> + ^ne-board-position-row <nebpr>)} + (position + ^row <nebpr> + ^column <nebpc> + ^state <> vacant + ^right-bent-state inside-a-segment) + (symbol + ^meaning piece-of-right-bent-segment + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <board-column>) + 2)) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type possibly-a-piece-of-vertical-segment + ^sw-board-position-column <sebpc> + ^nw-board-position-column <nebpc> + ^se-board-position-column (compute <sebpc> + 1) + ^ne-board-position-column (compute <nebpc> + 1))) + +(p drawing-of-a-piece-of-left-bent-segment-1 + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-bent-segment + ^nw-board-position-column <board-column> + ^board-row <board-row> + ^sw-board-position-column <swbpc> + ^nw-board-position-column <nwbpc> + ^se-board-position-column <sebpc> + ^ne-board-position-column <nebpc> + ^se-board-position-row <sebpr>)} + (position + ^row <sebpr> + ^column <sebpc> + ^state <> vacant + ^left-bent-state inside-a-segment) + (symbol + ^meaning piece-of-left-bent-segment + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <board-column>) + 2)) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type possibly-a-piece-of-vertical-segment + ^sw-board-position-column <sebpc> + ^nw-board-position-column <nebpc> + ^se-board-position-column (compute <sebpc> + 1) + ^ne-board-position-column (compute <nebpc> + 1))) + +(p drawing-of-a-piece-of-left-bent-segment-2 + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-bent-segment + ^nw-board-position-column <board-column> + ^board-row <board-row> + ^sw-board-position-column <swbpc> + ^nw-board-position-column <nwbpc> + ^se-board-position-column <sebpc> + ^ne-board-position-column <nebpc> + ^nw-board-position-row <nwbpr>)} + (position + ^row <nwbpr> + ^column <nwbpc> + ^state <> vacant + ^left-bent-state inside-a-segment) + (symbol + ^meaning piece-of-left-bent-segment + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <board-column>) + 2)) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type possibly-a-piece-of-vertical-segment + ^sw-board-position-column <sebpc> + ^nw-board-position-column <nebpc> + ^se-board-position-column (compute <sebpc> + 1) + ^ne-board-position-column (compute <nebpc> + 1))) + +(p drawing-of-a-crossing-of-segments-1 + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-bent-segment + ^nw-board-position-column <board-column> + ^board-row <board-row> + ^sw-board-position-column <swbpc> + ^nw-board-position-column <nwbpc> + ^se-board-position-column <sebpc> + ^ne-board-position-column <nebpc> + ^se-board-position-row <sebpr> + ^sw-board-position-row <swbpr>)} + (position + ^row <swbpr> + ^column <swbpc> + ^state <> vacant + ^right-bent-state inside-a-segment) + (position + ^row <sebpr> + ^column <sebpc> + ^state <> vacant + ^left-bent-state inside-a-segment) + (symbol + ^meaning crossing-of-two-bent-segments + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <board-column>) + 2)) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type possibly-a-piece-of-vertical-segment + ^sw-board-position-column <sebpc> + ^nw-board-position-column <nebpc> + ^se-board-position-column (compute <sebpc> + 1) + ^ne-board-position-column (compute <nebpc> + 1))) + +(p drawing-of-a-crossing-of-segments-2 + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-bent-segment + ^nw-board-position-column <board-column> + ^board-row <board-row> + ^sw-board-position-column <swbpc> + ^nw-board-position-column <nwbpc> + ^se-board-position-column <sebpc> + ^ne-board-position-column <nebpc> + ^ne-board-position-row <nebpr> + ^nw-board-position-row <nwbpr>)} + (position + ^row <nwbpr> + ^column <nwbpc> + ^state <> vacant + ^left-bent-state inside-a-segment) + (position + ^row <nebpr> + ^column <nebpc> + ^state <> vacant + ^right-bent-state inside-a-segment) + (symbol + ^meaning crossing-of-two-bent-segments + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <board-column>) + 2)) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type possibly-a-piece-of-vertical-segment + ^sw-board-position-column <sebpc> + ^nw-board-position-column <nebpc> + ^se-board-position-column (compute <sebpc> + 1) + ^ne-board-position-column (compute <nebpc> + 1))) + +(p drawing-of-a-crossing-of-segments-3 + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-bent-segment + ^nw-board-position-column <board-column> + ^board-row <board-row> + ^sw-board-position-column <swbpc> + ^nw-board-position-column <nwbpc> + ^se-board-position-column <sebpc> + ^ne-board-position-column <nebpc> + ^ne-board-position-row <nebpr> + ^se-board-position-row <sebpr>)} + (position + ^row <sebpr> + ^column <sebpc> + ^state <> vacant + ^left-bent-state inside-a-segment) + (position + ^row <nebpr> + ^column <nebpc> + ^state <> vacant + ^right-bent-state inside-a-segment) + (symbol + ^meaning crossing-of-two-bent-segments + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <board-column>) + 2)) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type possibly-a-piece-of-vertical-segment + ^sw-board-position-column <sebpc> + ^nw-board-position-column <nebpc> + ^se-board-position-column (compute <sebpc> + 1) + ^ne-board-position-column (compute <nebpc> + 1))) + +(p drawing-of-a-crossing-of-segments-4 + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-bent-segment + ^nw-board-position-column <board-column> + ^board-row <board-row> + ^sw-board-position-column <swbpc> + ^nw-board-position-column <nwbpc> + ^se-board-position-column <sebpc> + ^ne-board-position-column <nebpc> + ^nw-board-position-row <nwbpr> + ^sw-board-position-row <swbpr>)} + (position + ^row <swbpr> + ^column <swbpc> + ^state <> vacant + ^right-bent-state inside-a-segment) + (position + ^row <nwbpr> + ^column <nwbpc> + ^state <> vacant + ^left-bent-state inside-a-segment) + (symbol + ^meaning crossing-of-two-bent-segments + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <board-column>) + 2)) + (write (tabto <tab>) + <drawing-character>) + (modify <drawing-position-printed> + ^type possibly-a-piece-of-vertical-segment + ^sw-board-position-column <sebpc> + ^nw-board-position-column <nebpc> + ^se-board-position-column (compute <sebpc> + 1) + ^ne-board-position-column (compute <nebpc> + 1))) + +(p non-drawing-of-an-intermediate-position-of-an-intermediate-line + (game-state ^current-context board-drawing) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-bent-segment + ^board-row <board-row> + ^sw-board-position-column <swbpc> + ^nw-board-position-column <nwbpc> + ^se-board-position-column <sebpc> + ^ne-board-position-column <nebpc> + ^nw-board-position-row <nwbpr> + ^sw-board-position-row <swbpr>)} +--> + (modify <drawing-position-printed> + ^type possibly-a-piece-of-vertical-segment + ^sw-board-position-column <sebpc> + ^nw-board-position-column <nebpc> + ^se-board-position-column (compute <sebpc> + 1) + ^ne-board-position-column (compute <nebpc> + 1))) + +(p drawing-of-the-end-of-an-intermediate-line-1 + (game-state ^current-context board-drawing) + (board-parameters + ^nb-of-columns <nbbc>) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-vertical-segment + ^nw-board-position-column <nbbc> + ^board-row <board-row> + ^sw-board-position-row <swbpr>)} + (position + ^row <swbpr> + ^column <nbbc> + ^state <> vacant + ^vertical-state inside-a-segment) + (symbol + ^meaning piece-of-vertical-segment + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <nbbc>))) + (write (tabto <tab>) + <drawing-character> + (crlf)) + (modify <drawing-position-printed> + ^type outside-board + ^line-type board-line + ^board-row (compute <board-row> + 1))) + +(p drawing-of-the-end-of-an-intermediate-line-2 + (game-state ^current-context board-drawing) + (board-parameters + ^nb-of-columns <nbbc>) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-vertical-segment + ^nw-board-position-column <nbbc> + ^board-row <board-row> + ^nw-board-position-row <nwbpr>)} + (position + ^row <nwbpr> + ^column <nbbc> + ^state <> vacant + ^vertical-state inside-a-segment) + (symbol + ^meaning piece-of-vertical-segment + ^drawing-character <drawing-character>) +--> + (bind <tab> (compute 2 + (4 * <nbbc>))) + (write (tabto <tab>) + <drawing-character> + (crlf)) + (modify <drawing-position-printed> + ^type outside-board + ^line-type board-line + ^board-row (compute <board-row> + 1))) + +(p non-drawing-of-the-end-of-an-intermediate-line + (game-state ^current-context board-drawing) + (board-parameters + ^nb-of-columns <nbbc>) + {<drawing-position-printed> + (drawing-position-printed + ^line-type intermediate-line + ^type possibly-a-piece-of-vertical-segment + ^nw-board-position-column <nbbc> + ^board-row <board-row> + ^nw-board-position-row <nwbpr>)} +--> + (modify <drawing-position-printed> + ^type outside-board + ^line-type board-line + ^board-row (compute <board-row> + 1)) + (write (crlf))) + + + +(p choice-of-a-move-by-human + {<game-state> + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-the-move + ^current-player human)} +--> + (write |Where do you play (row column)?|) + (make input ^type position ^value (acceptline))) + +(p correction-of-a-move-by-human + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-the-move + ^current-player human) + {(input ^type position) <input>} +--> + (write |Your move is illegal.| + (crlf) + |Where do you play (row column)?|) + (modify <input> + ^value (acceptline))) + +(p end-of-the-choice-of-the-move + {<game-state> + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-the-move + ^current-player human)} + {(input + ^type position + ^value <row> <column>) <input>} + (position + ^row <row> + ^column <column> + ^state vacant) +--> + (make new-move + ^row <row> + ^column <column> + ^state human) + (remove <input>) + (modify <game-state> + ^current-context board-analyse + ^current-sub-context garbage-cleaning)) + +(p asking-the-human-whether-he-wants-to-draw-a-segment + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^current-player human) + -(segment) + -(input) +--> +(write |Segment to draw (ret., or beginning row & column, ending ...)?|) + (make input + ^type segment + ^value (acceptline no read))) + +(p asking-the-human-whether-he-wants-to-draw-another-segment + {<game-state> + (game-state + ^current-context choice-of-a-move + ^current-player human)} +--> + (modify <game-state> + ^current-context choice-of-a-move)) + +(p removal-of-a-negative-segment-input + {(game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^current-player human) <game-state>} + {(input + ^type segment + ^value no) <input>} +--> + (remove <input>) + (modify <game-state> + ^current-context choice-of-a-move + ^current-sub-context generation-of-the-best-possible-moves + ^current-player computer)) + +(p drawing-of-a-segment-by-human + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^current-player human) + {(input + ^type segment + ^value {<> no <beginning-row>} + <beginning-column> + <ending-row> + <ending-column>) <input>} +--> + (make segment + ^beginning-row <beginning-row> + ^beginning-column <beginning-column> + ^ending-row <ending-row> + ^ending-column <ending-column>) + (remove <input>)) + +(p orientation-of-a-non-vertical-segment + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^current-player human) + {<segment> + (segment + ^beginning-row <beginning-row> + ^ending-row <ending-row> + ^beginning-column <beginning-column> + ^ending-column {<ending-column> < <beginning-column>})} +--> + (modify <segment> + ^beginning-row <ending-row> + ^ending-row <beginning-row> + ^beginning-column <ending-column> + ^ending-column <beginning-column>)) + + (p orientation-of-a-vertical-segment + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^current-player human) + {<segment> + (segment + ^beginning-column <column> + ^ending-column <column> + ^beginning-row <beginning-row> + ^ending-row {<ending-row> < <beginning-row>})} +--> + (modify <segment> + ^beginning-row <ending-row> + ^ending-row <beginning-row>)) + +(p checking-of-the-legality-of-a-horizontal-oriented-segment + {<game-state> + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^current-player human + ^human-score <human-score>)} + {<segment> + (segment + ^beginning-row <row> + ^ending-row <row> + ^beginning-column <beginning-column> + ^ending-column <ending-column>)} + (incrementation + ^nb <beginning-column> + ^nb-incremented <column2>) + (incrementation + ^nb <column2> + ^nb-incremented <column3>) + (incrementation + ^nb <column3> + ^nb-incremented <column4>) + {<position1> + (position + ^column <beginning-column> + ^row <row> + ^state human + ^horizontal-state << free end-of-a-segment >>)} + {<position2> + (position + ^column <column2> + ^row <row> + ^state human + ^horizontal-state << free end-of-a-segment >>)} + {<position3> + (position + ^column <column3> + ^row <row> + ^state human + ^horizontal-state << free end-of-a-segment >>)} + {<position4> + (position + ^column {<ending-column> <column4>} + ^row <row> + ^state human + ^horizontal-state << free end-of-a-segment >>)} +--> + (modify <position1> + ^horizontal-state end-of-a-segment) + (modify <position2> + ^horizontal-state inside-a-segment) + (modify <position3> + ^horizontal-state inside-a-segment) + (modify <position4> + ^horizontal-state end-of-a-segment) + (modify <game-state> + ^human-score (compute <human-score> + 1)) + (remove <segment>)) + +(p checking-of-the-legality-of-a-vertical-oriented-segment + {<game-state> + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^current-player human + ^human-score <human-score>)} + {<segment> + (segment + ^beginning-column <column> + ^ending-column <column> + ^beginning-row <beginning-row> + ^ending-row <ending-row>)} + (incrementation + ^nb <beginning-row> + ^nb-incremented <row2>) + (incrementation + ^nb <row2> + ^nb-incremented <row3>) + (incrementation + ^nb <row3> + ^nb-incremented <row4>) + {<position1> + (position + ^row <beginning-row> + ^column <column> + ^state human + ^vertical-state << free end-of-a-segment >>)} + {<position2> + (position + ^row <row2> + ^column <column> + ^state human + ^vertical-state << free end-of-a-segment >>)} + {<position3> + (position + ^row <row3> + ^column <column> + ^state human + ^vertical-state << free end-of-a-segment >>)} + {<position4> + (position + ^row {<ending-row> <row4>} + ^column <column> + ^state human + ^vertical-state << free end-of-a-segment >>)} +--> + (modify <position1> + ^vertical-state end-of-a-segment) + (modify <position2> + ^vertical-state inside-a-segment) + (modify <position3> + ^vertical-state inside-a-segment) + (modify <position4> + ^vertical-state end-of-a-segment) + (modify <game-state> + ^human-score (compute <human-score> + 1)) + (remove <segment>)) + +(p checking-of-the-legality-of-a-left-bent-oriented-segment + {<game-state> + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^current-player human + ^human-score <human-score>)} + {<segment> + (segment + ^beginning-column <beginning-column> + ^ending-column <ending-column> + ^beginning-row <beginning-row> + ^ending-row <ending-row>)} + (incrementation + ^nb <beginning-row> + ^nb-incremented <row2>) + (incrementation + ^nb <row2> + ^nb-incremented <row3>) + (incrementation + ^nb <row3> + ^nb-incremented <row4>) + (incrementation + ^nb <beginning-column> + ^nb-incremented <column2>) + (incrementation + ^nb <column2> + ^nb-incremented <column3>) + (incrementation + ^nb <column3> + ^nb-incremented <column4>) + {<position1> + (position + ^row <beginning-row> + ^column <beginning-column> + ^state human + ^left-bent-state << free end-of-a-segment >>)} + {<position2> + (position + ^row <row2> + ^column <column2> + ^state human + ^left-bent-state << free end-of-a-segment >>)} + {<position3> + (position + ^row <row3> + ^column <column3> + ^state human + ^left-bent-state << free end-of-a-segment >>)} + {<position4> + (position + ^row {<ending-row> <row4>} + ^column {<ending-column> <column4>} + ^state human + ^left-bent-state << free end-of-a-segment >>)} +--> + (modify <position1> + ^left-bent-state end-of-a-segment) + (modify <position2> + ^left-bent-state inside-a-segment) + (modify <position3> + ^left-bent-state inside-a-segment) + (modify <position4> + ^left-bent-state end-of-a-segment) + (modify <game-state> + ^human-score (compute <human-score> + 1)) + (remove <segment>)) + +(p checking-of-the-legality-of-a-right-bent-oriented-segment + {<game-state> + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^current-player human + ^human-score <human-score>)} + {<segment> + (segment + ^beginning-row <beginning-row> + ^ending-row <ending-row> + ^beginning-column <beginning-column> + ^ending-column <ending-column>)} + (incrementation + ^nb <beginning-column> + ^nb-incremented <column2>) + (incrementation + ^nb <column2> + ^nb-incremented <column3>) + (incrementation + ^nb <column3> + ^nb-incremented <column4>) + (incrementation + ^nb <ending-row> + ^nb-incremented <row3>) + (incrementation + ^nb <row3> + ^nb-incremented <row2>) + (incrementation + ^nb <row2> + ^nb-incremented <row1>) + {<position1> + (position + ^column <beginning-column> + ^row {<row1> <beginning-row>} + ^state human + ^right-bent-state << free end-of-a-segment >>)} + {<position2> + (position + ^column <column2> + ^row <row2> + ^state human + ^right-bent-state << free end-of-a-segment >>)} + {<position3> + (position + ^column <column3> + ^row <row3> + ^state human + ^right-bent-state << free end-of-a-segment >>)} + {<position4> + (position + ^column {<ending-column> <column4>} + ^row <ending-row> + ^state human + ^right-bent-state << free end-of-a-segment >>)} +--> + (modify <position1> + ^right-bent-state end-of-a-segment) + (modify <position2> + ^right-bent-state inside-a-segment) + (modify <position3> + ^right-bent-state inside-a-segment) + (modify <position4> + ^right-bent-state end-of-a-segment) + (modify <game-state> + ^human-score (compute <human-score> + 1)) + (remove <segment>)) + +(p correction-of-a-segment + {<game-state> + (game-state + ^current-context choice-of-a-move + ^current-sub-context choice-of-segments + ^current-player human + ^human-score <human-score>)} + {<segment> + (segment + ^beginning-row <beginning-row> + ^ending-row <ending-row> + ^beginning-column <beginning-column> + ^ending-column <ending-column>)} +--> + (remove <segment>) + (write |Your segment is illegal.| + (crlf) + |Segment to draw (ret., or beginning row & column, ending ...)?|) + (make input + ^type segment + ^value (acceptline no read))) + + + + + + + + + + + + + + + + +(p fbug-start + (start) + --> + (make position + ^row 0 + ^column 0 + ^state edge + ^vertical-state nil + ^horizontal-state nil + ^right-bent-state nil + ^left-bent-state nil) + (make opposite ^of human ^is computer) + (make opposite ^of computer ^is human) + (make board-parameters + ^nb-of-columns 10 + ^nb-of-rows 10 + ^nb-of-columns-incr 11 + ^nb-of-rows-incr 11 + ^max-board-size 10 + ^max-board-size-incr 11) + (make symbol + ^meaning vacant + ^drawing-character |.|) + (make symbol + ^meaning human + ^drawing-character |o|) + (make symbol + ^meaning computer + ^drawing-character |*|) + (make symbol + ^meaning piece-of-horizontal-segment + ^drawing-character |-|) + (make symbol + ^meaning piece-of-vertical-segment + ^drawing-character |l|) + (make symbol + ^meaning piece-of-right-bent-segment + ^drawing-character |/|) + (make symbol + ^meaning piece-of-left-bent-segment + ^drawing-character |\|) + (make symbol + ^meaning crossing-of-two-bent-segments + ^drawing-character |x|) + (make game-state + ^current-context initialisations + ^human-score 0 + ^computer-score 0) + (make delta 0) + (make delta 1) + (make delta -1) + (make nb 0) + (make nb 1) + (make nb 2) + (make nb 3) + (make nb 4) + (make nb 5) + (make nb 6) + (make nb 7) + (make nb 8) + (make nb 9) + (make nb 10) + (make nb 11) + (make length 4) + (make length 5) + (make length 6) + (make length 7) + (make incrementation + ^nb 0 + ^nb-incremented 1) + (make direction ^geometry assymetric ^row 0 ^column 1) + (make direction ^geometry assymetric ^row 1 ^column 1) + (make direction ^geometry assymetric ^row 1 ^column 0) + (make direction ^geometry assymetric ^row 1 ^column -1) + (make direction ^geometry assymetric ^row 0 ^column -1) + (make direction ^geometry assymetric ^row -1 ^column -1) + (make direction ^geometry assymetric ^row -1 ^column 0) + (make direction ^geometry assymetric ^row -1 ^column 1) + (make direction ^geometry symetric ^row 0 ^column 1) + (make direction ^geometry symetric ^row 1 ^column 1) + (make direction ^geometry symetric ^row 1 ^column 0) + (make direction ^geometry symetric ^row 1 ^column -1) + (make number-to-add-while-updating-counters ^value ignore-it) + (make segment-type + ^name opcxcpo + ^length 7 + ^geometry symetric + ^owner computer + ^position-1-state human + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state computer + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state human + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage + ^position-7-counter-to-update garbage) + (make segment-type + ^name ipcxcpo + ^length 7 + ^geometry assymetric + ^owner computer + ^position-1-state edge + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state computer + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state human + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage + ^position-7-counter-to-update garbage) + (make segment-type + ^name ipcxcpi + ^length 7 + ^geometry symetric + ^owner computer + ^position-1-state edge + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state computer + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state edge + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage + ^position-7-counter-to-update garbage) + (make segment-type + ^name pccxccp + ^length 7 + ^geometry symetric + ^owner computer + ^position-1-state vacant + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state computer + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update nb-of-compulsory-answer-creations + ^position-7-counter-to-update garbage) + (make segment-type + ^name opcxccp + ^length 7 + ^geometry assymetric + ^owner computer + ^position-1-state human + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state computer + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update nb-of-compulsory-answer-creations + ^position-7-counter-to-update garbage) + (make segment-type + ^name ipcxccp + ^length 7 + ^geometry assymetric + ^owner computer + ^position-1-state edge + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state computer + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update nb-of-compulsory-answer-creations + ^position-7-counter-to-update garbage) + (make segment-type + ^name cxfxc + ^length 5 + ^geometry symetric + ^owner computer + ^position-1-state vacant + ^position-2-state computer + ^position-3-state vacant + ^position-4-state computer + ^position-5-state vacant + ^position-1-counter-to-update nb-of-compulsory-answer-creations + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-fragile-winners + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name oxxcc + ^length 5 + ^geometry assymetric + ^owner human + ^position-1-state human + ^position-2-state computer + ^position-3-state computer + ^position-4-state vacant + ^position-5-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update nb-of-compulsory-answer-creations + ^position-5-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name ixxcc + ^length 5 + ^geometry assymetric + ^owner human + ^position-1-state edge + ^position-2-state computer + ^position-3-state computer + ^position-4-state vacant + ^position-5-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update nb-of-compulsory-answer-creations + ^position-5-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name oxxfx + ^length 5 + ^geometry assymetric + ^owner computer + ^position-1-state human + ^position-2-state computer + ^position-3-state computer + ^position-4-state vacant + ^position-5-state computer + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update nb-of-fragile-winners + ^position-5-counter-to-update garbage) + (make segment-type + ^name ixxfx + ^length 5 + ^geometry assymetric + ^owner computer + ^position-1-state edge + ^position-2-state computer + ^position-3-state computer + ^position-4-state vacant + ^position-5-state computer + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update nb-of-fragile-winners + ^position-5-counter-to-update garbage) + (make segment-type + ^name ocxxco + ^length 6 + ^geometry symetric + ^owner computer + ^position-1-state human + ^position-2-state vacant + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-6-state human + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage) + (make segment-type + ^name icxxco + ^length 6 + ^geometry assymetric + ^owner computer + ^position-1-state edge + ^position-2-state vacant + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-6-state human + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage) + (make segment-type + ^name icxxci + ^length 6 + ^geometry symetric + ^owner computer + ^position-1-state edge + ^position-2-state vacant + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-6-state edge + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage) + (make segment-type + ^name ocxxfc + ^length 6 + ^geometry assymetric + ^owner computer + ^position-1-state human + ^position-2-state vacant + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-6-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name icxxfc + ^length 6 + ^geometry assymetric + ^owner computer + ^position-1-state edge + ^position-2-state vacant + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-6-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name ocxxfx + ^length 6 + ^geometry assymetric + ^owner computer + ^position-1-state human + ^position-2-state vacant + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-6-state computer + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update garbage) + (make segment-type + ^name icxxfx + ^length 6 + ^geometry assymetric + ^owner computer + ^position-1-state edge + ^position-2-state vacant + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-6-state computer + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update garbage) + (make segment-type + ^name cfxxfc + ^length 6 + ^geometry symetric + ^owner computer + ^position-1-state vacant + ^position-2-state vacant + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-6-state vacant + ^position-1-counter-to-update nb-of-compulsory-answer-creations + ^position-2-counter-to-update nb-of-fragile-winners + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name xfxxfc + ^length 6 + ^geometry assymetric + ^owner computer + ^position-1-state computer + ^position-2-state vacant + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-6-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-fragile-winners + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name xwxxwx + ^length 6 + ^geometry symetric + ^owner computer + ^position-1-state computer + ^position-2-state vacant + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-6-state computer + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-strong-winners + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-strong-winners + ^position-6-counter-to-update garbage) + (make segment-type + ^name oxxxf + ^length 5 + ^geometry assymetric + ^owner computer + ^position-1-state human + ^position-2-state computer + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners) + (make segment-type + ^name ixxxf + ^length 5 + ^geometry assymetric + ^owner computer + ^position-1-state edge + ^position-2-state computer + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners) + (make segment-type + ^name wxxxw + ^length 5 + ^geometry symetric + ^owner computer + ^position-1-state vacant + ^position-2-state computer + ^position-3-state computer + ^position-4-state computer + ^position-5-state vacant + ^position-1-counter-to-update nb-of-strong-winners + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-strong-winners) + (make segment-type + ^name opcxcpo + ^length 7 + ^geometry symetric + ^owner human + ^position-1-state computer + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state human + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state computer + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage + ^position-7-counter-to-update garbage) + (make segment-type + ^name ipcxcpo + ^length 7 + ^geometry assymetric + ^owner human + ^position-1-state edge + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state human + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state computer + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage + ^position-7-counter-to-update garbage) + (make segment-type + ^name ipcxcpi + ^length 7 + ^geometry symetric + ^owner human + ^position-1-state edge + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state human + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state edge + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage + ^position-7-counter-to-update garbage) + (make segment-type + ^name pccxccp + ^length 7 + ^geometry symetric + ^owner human + ^position-1-state vacant + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state human + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update nb-of-compulsory-answer-creations + ^position-7-counter-to-update garbage) + (make segment-type + ^name opcxccp + ^length 7 + ^geometry assymetric + ^owner human + ^position-1-state computer + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state human + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update nb-of-compulsory-answer-creations + ^position-7-counter-to-update garbage) + (make segment-type + ^name ipcxccp + ^length 7 + ^geometry assymetric + ^owner human + ^position-1-state edge + ^position-2-state vacant + ^position-3-state vacant + ^position-4-state human + ^position-5-state vacant + ^position-6-state vacant + ^position-7-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-compulsory-answer-creations + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update nb-of-compulsory-answer-creations + ^position-7-counter-to-update garbage) + (make segment-type + ^name cxfxc + ^length 5 + ^geometry symetric + ^owner human + ^position-1-state vacant + ^position-2-state human + ^position-3-state vacant + ^position-4-state human + ^position-5-state vacant + ^position-1-counter-to-update nb-of-compulsory-answer-creations + ^position-2-counter-to-update garbage + ^position-3-counter-to-update nb-of-fragile-winners + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name oxxcc + ^length 5 + ^geometry assymetric + ^owner computer + ^position-1-state computer + ^position-2-state human + ^position-3-state human + ^position-4-state vacant + ^position-5-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update nb-of-compulsory-answer-creations + ^position-5-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name ixxcc + ^length 5 + ^geometry assymetric + ^owner computer + ^position-1-state edge + ^position-2-state human + ^position-3-state human + ^position-4-state vacant + ^position-5-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update nb-of-compulsory-answer-creations + ^position-5-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name oxxfx + ^length 5 + ^geometry assymetric + ^owner human + ^position-1-state computer + ^position-2-state human + ^position-3-state human + ^position-4-state vacant + ^position-5-state human + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update nb-of-fragile-winners + ^position-5-counter-to-update garbage) + (make segment-type + ^name ixxfx + ^length 5 + ^geometry assymetric + ^owner human + ^position-1-state edge + ^position-2-state human + ^position-3-state human + ^position-4-state vacant + ^position-5-state human + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update nb-of-fragile-winners + ^position-5-counter-to-update garbage) + (make segment-type + ^name ocxxco + ^length 6 + ^geometry symetric + ^owner human + ^position-1-state computer + ^position-2-state vacant + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-6-state computer + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage) + (make segment-type + ^name icxxco + ^length 6 + ^geometry assymetric + ^owner human + ^position-1-state edge + ^position-2-state vacant + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-6-state computer + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage) + (make segment-type + ^name icxxci + ^length 6 + ^geometry symetric + ^owner human + ^position-1-state edge + ^position-2-state vacant + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-6-state edge + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-compulsory-answer-creations + ^position-6-counter-to-update garbage) + (make segment-type + ^name ocxxfc + ^length 6 + ^geometry assymetric + ^owner human + ^position-1-state computer + ^position-2-state vacant + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-6-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name icxxfc + ^length 6 + ^geometry assymetric + ^owner human + ^position-1-state edge + ^position-2-state vacant + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-6-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name ocxxfx + ^length 6 + ^geometry assymetric + ^owner human + ^position-1-state computer + ^position-2-state vacant + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-6-state human + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update garbage) + (make segment-type + ^name icxxfx + ^length 6 + ^geometry assymetric + ^owner human + ^position-1-state edge + ^position-2-state vacant + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-6-state human + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-compulsory-answer-creations + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update garbage) + (make segment-type + ^name cfxxfc + ^length 6 + ^geometry symetric + ^owner human + ^position-1-state vacant + ^position-2-state vacant + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-6-state vacant + ^position-1-counter-to-update nb-of-compulsory-answer-creations + ^position-2-counter-to-update nb-of-fragile-winners + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name xfxxfc + ^length 6 + ^geometry assymetric + ^owner human + ^position-1-state human + ^position-2-state vacant + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-6-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-fragile-winners + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners + ^position-6-counter-to-update nb-of-compulsory-answer-creations) + (make segment-type + ^name xwxxwx + ^length 6 + ^geometry symetric + ^owner human + ^position-1-state human + ^position-2-state vacant + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-6-state human + ^position-1-counter-to-update garbage + ^position-2-counter-to-update nb-of-strong-winners + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-strong-winners + ^position-6-counter-to-update garbage) + (make segment-type + ^name oxxxf + ^length 5 + ^geometry assymetric + ^owner human + ^position-1-state computer + ^position-2-state human + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners) + (make segment-type + ^name ixxxf + ^length 5 + ^geometry assymetric + ^owner human + ^position-1-state edge + ^position-2-state human + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-1-counter-to-update garbage + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-fragile-winners) + (make segment-type + ^name wxxxw + ^length 5 + ^geometry symetric + ^owner human + ^position-1-state vacant + ^position-2-state human + ^position-3-state human + ^position-4-state human + ^position-5-state vacant + ^position-1-counter-to-update nb-of-strong-winners + ^position-2-counter-to-update garbage + ^position-3-counter-to-update garbage + ^position-4-counter-to-update garbage + ^position-5-counter-to-update nb-of-strong-winners) + (make move-type-classification + ^type fragile-winner + ^is-better-than-type multiple-fragile-winners-creation) + (make move-type-classification + ^type fragile-winner + ^is-better-than-type agressivity) + (make move-type-classification + ^type multiple-fragile-winners-creation + ^is-better-than-type agressivity) + (make move-type + ^name agressivity + ^point-of-views&counters-to-add + human nb-of-compulsory-answer-creations + computer nb-of-strong-winners + ^comment nil) + (make move-type + ^name multiple-fragile-winners-creation + ^point-of-views&counters-to-add + computer nb-of-compulsory-answer-creations + human nb-of-strong-winners + ^comment need-to-be-validated-separetely) + (make move-type + ^name fragile-winner + ^point-of-views&counters-to-add + computer nb-of-fragile-winners human nb-of-fragile-winners + ^comment nil) +) + + + diff --git a/contrib/ops/haunt.ops b/contrib/ops/haunt.ops new file mode 100644 index 000000000..4de108e6e --- /dev/null +++ b/contrib/ops/haunt.ops @@ -0,0 +1,6745 @@ +;;; Source code for the haunt program by John Laird + +;;; Added comment, -BGM 2/3/89 +(defmacro comment (&rest r) `',r) + +(comment Haunt mps OPS5 productions for haunt) + +(strategy mea) + +(literalize current type name) + +(literalize links id name type) + +(literalize object name holds state inside scored xscore alive +place side north south east up contains covered tied wears asleep treasure) + +(literalize location name side north south east up underwater book book2 +ontop siton general) + + (literalize portal name door status) + + (literalize place name visited state water virgin) + + (literalize history atetoken northpole forever hiwater grave_status +grave_status2 hungry clue bus_stopped) + + (literalize command string) + + (literalize control state special) + + (literalize time realtime cancer morning midnight orc_status orc_time + oil_status oil_time btime) + + (literalize status score die died bdie likes sound went going answer noway + quit notreasure cut) + +(comment **************** Start the show ****************) + +(p name01 + (x 0) + (current ^type operator ^name readfirst) + (input) + --> + (remove 3) + (write (crlf) |I assume that means yes.|) + (modify 2 ^type operator ^name read)) + +(p name02 + (x 10) + (current ^type operator ^name readfirst) + (input << yes y oui nothing >>) + --> + (remove 3) + (modify 2 ^type operator ^name read)) + +(p name06 + (x 0) + (current ^type operator ^name process) + (input) + --> + (write (crlf) |What?|) + (remove 3) + (modify 2 ^name read)) + +(p name07 + (x 10) + (current ^type operator ^name process) + (status ^going <> nil) + --> + (write (crlf) |You can't go that way.|) + (modify 2 ^name read) + (modify 3 ^going nil)) + +(p name08 + (x 10) + (current ^type operator ^name process) + (status ^going nil) +-(input) + --> + (modify 2 ^type operator ^name read)) + +(p name09 + (x 10) + (current ^type operator ^name read) + (status ^going nil) + (time ^realtime <x>) +-(input) + --> + (modify 2 ^type operator ^name process) + (write (crlf) |*|) + (make input (acceptline nothing read)) + (modify 4 ^realtime (compute <x> + 2))) + +(p name010 + (x 50) + (current ^type operator ^name readfirst) + --> + (write (crlf) |This is HAUNT. Version 4.6|) + (write (crlf) |See NEWS for news.|) + (write (crlf) |Have you played before?| (crlf) |*|) + (make input (accept)) + (write (crlf) | |)) + +(p name011 + (x 20) + (current ^type operator ^name read) +-(location) + --> + (make location ^name bus_stop)) + +(p name012 + (x 40) + (current ^type operator ^name readfirst) + (input << n no >>) + --> + (remove 3) + (modify 2 ^name read) + (write (crlf) |Welcome novice. You are playing one of the world's largest|) + (write (crlf) |production systems. The purpose of this game is to find|) + (write (crlf) |treasure in a haunted house and then escape from the house.|) + (write (crlf) | |) + (write (crlf) |The program will give descriptions of locations and accept|) + (write (crlf) |commands to perform actions.|) + (write (crlf) |Give it directives with simple 1-5 word commands.|) + (write (crlf) |Its knowledge of English is limited but imaginative.|) + (write (crlf) |The directions are north, south, east, west,|) + (write (crlf) |up and down. Directions can be one letter (n,s,e,w,u,d).|) + (write (crlf) |Forward, back, left and right also work.|) + (write (crlf) |To string commands together use 'then'. (eg. west then s)|) + (write (crlf) |It will describe things to you, and a phrase enclosed in ' ' |) + (write (crlf) |is something it hears.|) + (write (crlf) | |) + (write (crlf) |Special commands: INVEN tells you what you hold.|) + (write (crlf) | SCORE gives your current score. |) + (write (crlf) | STOP ends the adventure. |) + (write (crlf) | LOOK describes your current position.|) + (write (crlf) | NEWS describes new features.|) + (write (crlf) | |) + (write (crlf) |*************************************************************|) + (write (crlf) |You get 15 points for finding a treasure and 5 points for|) + (write (crlf) |getting it to the lawn outside the house. You get an extra|) + (write (crlf) |bonus of 20 points for getting your body off the estate.|) + (write (crlf) |The maximum number of points is 440|) + (write (crlf) |Good luck, you'll need it. Ask for help if you want.|) + (write (crlf) |*************************************************************|) + (write (crlf) |Copyright (C) 1979, 1980, 1981, 1982, 1983 John Laird|) + (write (crlf) |*************************************************************|) + (write (crlf) | |) + (write (crlf) |On with the adventure!!|) + (write (crlf) | |) + (write (crlf) | |) + (write (crlf) | |) + (write (crlf) | |) + (write (crlf) | |) + (write (crlf) | |) + (write (crlf) | |) + (write (crlf) | |) + (write (crlf) | |) + (write (crlf) | |) + (write (crlf) |Along time ago, a young couple was picnicing near the woods|) + (write (crlf) |on the outskirts of town. They were celebrating the birth|) + (write (crlf) |of their first child. Unfortunately, a crazed moose|) + (write (crlf) |inhabited that area and attacked them. The child and husband|) + (write (crlf) |were unharmed, but the wife was gored to death by the moose.|) + (write (crlf) | |) + (write (crlf) |After the funeral, the man bought the land where the incident occurred|) + (write (crlf) |and constructed a large mansion: CHEZ MOOSE. He filled it|) + (write (crlf) |with the treasures of his family and claimed that his wife's|) + (write (crlf) |soul was still in the area. He vowed to remain in the|) + (write (crlf) |mansion until he had returned her soul to human flesh.|) + (write (crlf) |He tried to bridge the gap between life and death to reclaim her.|) + (write (crlf) |Some say he was insane with grief, but others claimed that the madness was|) + (write (crlf) |in his blood, and his wife's death brought it to the surface.|) + (write (crlf) |After he entered the house, he never returned, and was declared dead |) + (write (crlf) |seven years later. Several people have entered the mansion|) + (write (crlf) |looking for him but none of them have ever returned.|) + (write (crlf) |There were rumors that he and his wife now haunt the house.|) + (write (crlf) | |) + (write (crlf) |That would be the end of the story except that the house|) + (write (crlf) |still stands and is filled with priceless treasures.|) + (write (crlf) |The house and all its contents are willed to his only descendant.|) + (write (crlf) |Oh yes, I forgot to tell you, the day the mother was killed,|) + (write (crlf) |the child was stolen by Gypsies.|) + (write (crlf) |The Will claims that only the descendant will know|) + (write (crlf) |how to avoid going crazy and committing suicide|) + (write (crlf) |while spending a night in the mansion.|) + (write (crlf) |An obscure hereditary disease, Orkhisnoires sakioannes,|) + (write (crlf) |is supposed to play some part in this.|) + (write (crlf) | |) + (write (crlf) |So if your heritage is in doubt, you may be the descendant|) + (write (crlf) |that can claim the treasure in the mansion.|) + (write (crlf) |Many people, claiming to be descendants have died trying...|) + (write (crlf) | or at least never returned.|) + (write (crlf) | |) + (write (crlf) |The terms of the Will say you get to keep any treasure|) + (write (crlf) |you get to the lawn, but of course you must also get off the premises alive.|) + (write (crlf) |Because the house is haunted it must be destroyed, and nobody|) + (write (crlf) |would be crazy enough to try and recover the rest of the treasure.|) + (write (crlf) |If you do get out, the government has agreed to|) + (write (crlf) |buy the land and destroy the house.|) + (write (crlf) | |) + (write (crlf) |If you are insane enough to try, your adventure starts at a bus stop.|) + (write (crlf) |Remember, type STOP to end the adventure.|) + (write (crlf) | |)) + +(p name013 + (start) + --> + (make current ^type operator ^name readfirst) + (remove 1) + (make x 0) + (make x 10) + (make x 20) + (make x 30) + (make x 40) + (make x 50) + (make x 60)) + +(p name1005 + (x 60) + (current ^type operator ^name readfirst) + --> + (make status ^score 0 ^went w ^sound on) + (make object ^name elevator ^place H) + (make object ^name candlesticks ^place dining_room ^treasure t) + (make object ^name ghost ^place cheese_room) + (make object ^name candy ^place foyer) + (make object ^name jade ^place backroom ^treasure t) + (make object ^name soap ^place bathroom) + (make object ^name mattress ^place bedroom) + (make object ^name chest ^place ocean ^south 2 ^east 2 ^up 1 ^treasure t) + (make object ^name marijuana ^place secret_room ^treasure t) + (make object ^name bottle ^place bar) + (make object ^name painting ^place smelly_room ^covered t) + (make object ^name chair ^place main_hall ^treasure t) + (make object ^name stool ^place bar) + (make object ^name gold ^place small_closet ^treasure t) + (make object ^name Dracula ^place dark_room ^asleep t) + (make object ^name monster ^place laboratory) + (make object ^name coins ^place bathysphere ^treasure t) + (make object ^name corkscrew ^place wine_cellar ^treasure t) + (make object ^name wetsuit ^place closet) + (make object ^name speargun ^place bathysphere ^state loaded) + (make object ^name diamonds ^place cave ^treasure t) + (make object ^name cube ^place frig ^treasure t) + (make object ^name tokens ^place held) + (make object ^name orchid ^place lawn + ^side in ^east 3 ^north 7 ^state seed) + (make object ^name watch ^place held) + (make object ^name stairs ^state whole) + (make object ^name rope ^tied noose) + (make object ^name damsel ^alive t ^tied t) + (make object ^name turpentine ^inside bottle) + (make object ^name moray_eel ^alive t) + (make object ^name seamonster ^alive t) + (make object ^name octopus ^alive t) + (make portal ^name truck ^door closed) + (make portal ^name library ^door closed) + (make portal ^name casket ^door closed) + (make portal ^name grill ^door closed) + (make portal ^name elevator ^door closed) + (make portal ^name large_door ^door closed) + (make portal ^name safe ^door closed) + (make portal ^name rdoor ^door closed) + (make portal ^name wdoor ^door closed) + (make portal ^name closet ^door open) + (make portal ^name wall ^door closed) + (make time ^btime 2214 ^realtime 2200) + (make history ^grave_status undug) + (make place ^name bathtub ^water out) + (make place ^name foyer ^virgin t)) + +(p name1 + (x 50) + (location ^name <name>) +- (place ^name <name>) + --> + (make place ^name <name>)) + +(p name3 + (x 10) + (location ^name <y>) + (object ^name <x> ^place <> <y>) + (input <a> <x>) + --> + (remove 4) + (write (crlf) |The| <x> |is not here.|)) + +(p name4 + (x 30) + (input news) + --> + (remove 2) + (write (crlf) |Version 4.6, 6-21-82|) + (write (crlf) |As always, a few more bugs have been fixed.|) + (write (crlf) |Send gripes to John.Laird@CMUA.|) + (write (crlf) |Or John Laird, Computer Science Department|) + (write (crlf) |Carnegie-Mellon University, Pittsburgh, Pa. 15213|) + (write (crlf) |The max score is 440.|) + (write (crlf) |Copyright (C) 1979,1980,1981,1982,1983 John E. Laird|)) + +(p name5 + (x 30) + (input who is bzm <x>) + --> + (remove 2) + (write (crlf) |A famous graduate of CMU CSD.|)) + +(p name6 + (x 30) + (input xstat) + --> + (remove 2) + (halt)) + +(p name7 + (x 50) + (location ^name <x>) + (place ^name <x> ^visited t) + --> + (write (crlf) |You are in| <x> |.|)) + +(p name8 + (x 30) + (input <x> <y> on) + --> + (make input <x> on <y> (substr 2 5 inf)) + (remove 2)) + +(p name9 + (x 30) + (input <x> <y> off) + --> + (make input <x> off <y> (substr 2 5 inf)) + (remove 2)) + +(p name10 + (x 30) + (input <x> to <y>) + --> + (remove 2) + (make input <x> <y>)) + +(p name11 + (x 30) + (location ^name <x>) + (input gamma <y>) + --> + (remove 3) + (modify 2 ^name <y>)) + +(p name12 + (x 30) + (input <x> the) + --> + (remove 2) + (make input <x> (substr 2 4 inf))) + +(p name13 + (x 30) + (input <x> <y> the) + --> + (remove 2) + (make input <x> <y> (substr 2 5 inf))) + +(p name14 + (x 30) + (input <x> a) + --> + (remove 2) + (make input <x> (substr 2 4 inf))) + +(p name15 + (x 30) + (input <x> then) + --> + (remove 2) + (make input <x>) + (make input then (substr 2 4 inf))) + +(p name16 + (x 30) + (input <x> <y> then) + --> + (remove 2) + (make input <x> <y>) + (make input (substr 2 4 inf))) + +(p name17 + (x 30) + (input <x> <y> then <W> it) + --> + (remove 2) + (make input <x> <y>) + (make input then <W> <y> (substr 2 7 inf))) + +(p name18 + (x 30) + (input <x> {<> then <y>} <n> then) + --> + (remove 2) + (make input <x> <y> <n>) + (make input (substr 2 5 inf))) + +(p name19 + (x 30) + (input then) + (time ^realtime <y>) + --> + (remove 2) + (make input (substr 2 3 inf)) + (modify 3 ^realtime (compute <y> + 2))) + +(p name20 + (x 30) + (object ^name <y> ^place held) + (input <x> it) + --> + (remove 3) + (make input <x> <y> (substr 3 4 inf))) + +(p name21 + (x 30) + (object ^name <y> ^place <Z>) + (location ^name <Z>) + (input <x> it) + --> + (remove 4) + (make input <x> <y> (substr 4 4 inf))) + + +(comment ********Directions************************************************ ) + +(p name22 + (x 30) + (input {<< n s e w u d >> <direction>}) + (status) + --> + (remove 2) + (modify 3 ^going <direction> ^went <direction>)) + +(p name23 + (x 30) + (input << out leave >>) + --> + (make input exit (substr 2 3 inf)) + (remove 2)) + +(p name24 + (x 30) + (input get in) + --> + (remove 2) + (make input enter (substr 2 4 inf))) + +(p name25 + (x 30) + (input << walkin in inside >>) + --> + (remove 2) + (make input enter (substr 2 3 inf))) + +(p name26 + (x 30) + (input west) + (status) + --> + (remove 2) + (modify 3 ^going w ^went w)) + +(p name27 + (x 30) + (input east) + (status) + --> + (remove 2) + (modify 3 ^going e ^went e)) + +(p name28 + (x 30) + (input north) + (status) + --> + (remove 2) + (modify 3 ^going n ^went n)) + +(p name29 + (x 30) + (input south) + (status) + --> + (remove 2) + (modify 3 ^going s ^went s)) + +(p name30 + (x 30) + (input up) + (status) + --> + (remove 2) + (modify 3 ^going u ^went u)) + +(p name31 + (x 30) + (input down) + (status) + --> + (remove 2) + (modify 3 ^going d ^went d)) + +(p name32 + (x 30) + (status ^going n) + --> + (modify 2 ^going nil ^noway t)) + +(p name33 + (x 30) + (status ^going s) + --> + (modify 2 ^going nil ^noway t)) + +(p name34 + (x 30) + (status ^going w) + --> + (modify 2 ^going nil ^noway t)) + +(p name35 + (x 30) + (status ^going e) + --> + (modify 2 ^going nil ^noway t)) + +(p name36 + (x 30) + (status ^going d) + --> + (modify 2 ^going nil) + (write (crlf) |You can't go down from here.|)) + +(p name37 + (x 30) + (status ^going u) + --> + (modify 2 ^going nil) + (write (crlf) |There is nothing to go up on.|)) + +(p name38 + (x 30) + (status ^noway t) + --> + (write (crlf) |You can't go that way.|) + (modify 2 ^noway nil ^going nil)) + +(p name39 + (x 30) + (status ^went w) + (input right) + --> + (modify 2 ^going n ^went n) + (remove 3)) + +(p name40 + (x 30) + (status ^went <direction>) + (input forward) + --> + (modify 2 ^going <direction>) + (remove 3)) + +(p name41 + (x 30) + (status ^went s) + (input left) + --> + (modify 2 ^going e ^went e) + (remove 3)) + +(p name42 + (x 30) + (status ^went e) + (input left) + --> + (modify 2 ^going n ^went n) + (remove 3)) + +(p name43 + (x 30) + (status ^went e) + (input right) + --> + (modify 2 ^going s ^went s) + (remove 3)) + +(p name44 + (x 30) + (status ^went e) + (input back) + --> + (modify 2 ^going w ^went w) + (remove 3)) + +(p name45 + (x 30) + (status ^went s) + (input right) + --> + (modify 2 ^going w ^went w) + (remove 3)) + +(p name46 + (x 30) + (status ^went s) + (input back) + --> + (modify 2 ^going n ^went n) + (remove 3)) + +(p name47 + (x 30) + (status ^went n) + (input left) + --> + (modify 2 ^going w ^went w) + (remove 3)) + +(p name48 + (x 30) + (status ^went n) + (input right) + --> + (modify 2 ^going e ^went e) + (remove 3)) + +(p name49 + (x 30) + (status ^went n) + (input back) + --> + (modify 2 ^going s ^went s) + (remove 3)) + +(p name50 + (x 30) + (status ^went w) + (input left) + --> + (modify 2 ^going s ^went s) + (remove 3)) + +(p name51 + (x 30) + (status ^went u) + (input back) + --> + (modify 2 ^going d ^went d) + (remove 3)) + +(p name52 + (x 30) + (status ^went d) + (input back) + --> + (modify 2 ^going u ^went u) + (remove 3)) + +(p name53 + (x 30) + (status ^went w) + (input back) + --> + (modify 2 ^going e ^went e) + (remove 3)) + +(p name54 + (x 30) + (input ahead) + --> + (remove 2) + (make input forward)) + +(p name55 + (x 30) + (status ^went <y>) + (input direction) + --> + (remove 3) + (write (crlf) |You are facing | <y>)) + +(p name56 + (x 20) + (input exit) + --> + (remove 2) + (make input back)) + +(p name57 + (x 20) + (input enter <x>) + --> + (remove 2) + (write (crlf) |I can't enter| <x> |.|)) + +(p name58 + (x 30) + (input go nil) + --> + (make input forward) + (remove 2)) + +(p name59 + (x 30) + (input go <> nil) + --> + (remove 2) + (make input (substr 2 3 inf))) + + +(comment *****************Get and Drop************************************* ) + +(p name60 + (x 30) + (location ^name <x>) + (object ^name <n> ^place <x>) + (input get all) + --> + (make input get <n>)) + +(p name61 + (x 20) + (input get all) + --> + (remove 2) + (write (crlf) |OK, all done.|)) + +(p name62 + (x 30) + (object ^name <p> ^place held) + (input get <p>) + --> + (remove 3) + (write (crlf) |You already have| <p>)) + +(p name63 + (x 10) + (input get <p>) + --> + (remove 2) + (write (crlf) |I can't get| <p>)) + +(p name64 + (x 30) + (object ^name <x> ^place <p> ^side <s> ^north <n> ^east <e> ^state nil) + (location ^name <p> ^side <s> ^north <n> ^east <e>) + (input get <x>) + --> + (remove 4) + (modify 2 ^place held) + (write (crlf) |You just got| <x> |.|)) + +(p name65 + (x 40) + (object ^name monster ^place laboratory) + (location ^name laboratory) + (input get monster) + --> + (remove 4) + (write (crlf) |That would be a big mistake.|)) + +(p name66 + (x 40) + (object ^name cecil ^place <x>) + (location ^name <x>) + (input get cecil) + --> + (remove 4) + (write (crlf) |Cecil is a free spirit. He doesn't come with you.|)) + +(p name67 + (x 30) + (input << pull pickup grab pry lift take carry >> <x>) + --> + (remove 2) + (make input get <x>)) + +(p name68 + (x 30) + (input pick up <x>) + --> + (make input get <x>) + (remove 2)) + +(p name69 + (x 10) + (input drop all) + --> + (remove 2) + (write (crlf) |All dropped.|)) + +(p name70 + (x 30) + (input drop all) + (location ^name <p>) + (object ^name <n> ^place held) + --> + (make input drop <n>)) + +(p name71 + (x 20) + (object ^name <x> ^place held) + (location ^name <y> ^side <s> ^north <n> ^east <e>) + (input drop <x>) + --> + (remove 4) + (modify 2 ^place <y> ^side <s> ^north <n> ^east <e>)) + +(p name72 + (x 30) + (input << discard release >> <x>) + --> + (remove 2) + (make input drop <x>)) + +(p name73 + (x 10) + (object ^name <x> ^place <> held) + (input drop <x>) + --> + (remove 3) + (write (crlf) |You don't have| <x>)) + +(p name74 + (x 30) + (input put down <x>) + --> + (remove 2) + (make input drop <x>)) + +(p name75 + (x 30) + (input take off <x>) + --> + (remove 2) + (make input remove <x>)) + + +(comment *****************Inventory************************************ ) + +(p name76 + (x 30) + (object ^name <p> ^place held) + (input inven) + --> + (write (crlf) <p>)) + +(p name77 + (x 20) + (input inven) + --> + (remove 2)) + +(p name78 + (x 40) + (input inven) + --> + (write (crlf) |You have the following:|)) + +(p name79 + (x 30) + (input inventory) + --> + (remove 2) + (make input inven)) + +(p name80 + (x 30) + (object ^name <p> ^place held) + (object ^name <C> ^inside <p>) + (input inven) + --> + (write (crlf) <C>)) + +(p name81 + (x 50) +-(object ^name <x> ^place held) + (input inven) + --> + (remove 2) + (write (crlf) |You're empty handed.|)) + + +(comment ******************Random inputs********************************* ) + +(p name82 + (x 30) + (input run nil) + --> + (remove 2) + (write (crlf) |I'm going as fast as I can.|)) + +(p name83 + (x 30) + (input run <> nil) + --> + (remove 2) + (write (crlf) |I can't go any faster.|)) + +(p name84 + (x 30) + (input listen) + --> + (remove 2) + (write (crlf) |Silence!|)) + + +(p name85 + (x 30) + (status ^sound on) + (input listen) + --> + (remove 3) + (modify 2 ^sound on)) + +(p name86 + (x 30) + (input whistle) + --> + (remove 2) + (write (crlf) |What, without an accompanying orchestra?|)) + +(p name87 + (x 30) + (input hum) + --> + (remove 2) + (write (crlf) |Hum de dum de dum, hum hum dum dum de dum.|)) + +(p name88 + (x 30) + (input sing) + --> + (remove 2) + (write (crlf) |In-A-Gadda-Da-Vida Baby, don't you know that I love you.|)) + +(p name89 + (x 30) + (input mumble) + --> + (remove 2) + (write (crlf) |mumbmaubmmmsms|)) + +(p name90 + (x 30) + (status) + (input << quit halt stop >>) + --> + (remove 3) + (modify 2 ^quit t) + (write (crlf) |The party's over.|)) + + +(comment ***********************Death*************************************** ) + +(p name1007 + (x 40) + (status ^die t ^died t ^quit nil) + --> + (write (crlf) |Well, you're one more that didn't get the treasure and live.|) + (modify 2 ^quit t)) + +(p name1008 + (x 40) + (status ^die t ^score <Q> ^died nil) + --> + (modify 2 ^score (compute <Q> - 20) ^died t) + (write (crlf) |Hmm... you went and got yourself killed.|) + (write (crlf) |But I'll let you play a bit longer.|)) + +(p name96 + (x 30) +-(object ^name bottle ^place held) + (input pour) + --> + (remove 2) + (write (crlf) |You don't have a bottle full of anything.|)) + +(p name97 + (x 30) + (object ^name bottle ^place held) + (object ^name <x> ^inside bottle) + (input drink) +--> + (remove 4) + (remove 3) + (write (crlf) |I love that| <x> |for breakfast every morning.|)) + +(p name98 + (x 30) + (object ^name bottle ^place held) + (location ^name beach) + (input get sand) + --> + (remove 4) + (write (crlf) |The sand clogs in the neck of the bottle.|) + (write (crlf) |For all practical purposes you can't get any sand.|)) + +(p name99 + (x 30) + (object ^name bottle ^place held) + (location ^name beach) + (input fill bottle) + --> + (remove 4) + (make input get sand)) + + +(comment ********Treasure Objects***************************** ) + +(p name100 + (x 20) + (object ^name corkscrew ^place <x>) + (location ^name <x>) + --> + (write (crlf) |There is a diamond studded corkscrew here!|)) + +(p name101 + (x 30) + (object ^name corkscrew ^place held) + (input screw) + --> + (write (crlf)|Cork screwing is a little out of my league.|) + (remove 3)) + +(p name102 + (x 20) + (location ^name <x>) + (object ^name ring ^place <x>) + --> + (write (crlf) |There is a huge diamond ring here.|)) + + +(comment **************************Candy*************************************) + +(p name103 + (x 20) + (location ^name <x>) + (object ^name candy ^place <x>) + --> + (write (crlf) |There is a bowl of candy on the ground.|)) + +(p name104 + (x 30) + (input <x> bowl) + --> + (remove 2) + (make input <x> candy)) + +(p name105 + (x 30) + (object ^name candy ^place <x>) + (location ^name <x>) + (input eat candy) + --> + (write (crlf) |Candy tastes good; uhm!|) + (write (crlf) |Of course the pins in the Snickers take a little chewing.|) + (remove 2) + (remove 4)) + +(p name106 + (x 30) + (object ^name candy ^place held) + (input eat candy) + --> + (write (crlf) |You eat the candy; and get cavities.|) + (remove 2) + (remove 3)) + + +(comment *****************Marijuana************************************) + +(p name107 + (x 30) + (location ^name <x>) + (object ^name marijuana ^place <x>) + --> + (write (crlf) |There is some fine marijuana here! Good stuff.|)) + +(p name108 + (object ^name matches ^place held) + (location ^name lawn) + (input burn <x>) + --> + (remove 3) + (write (crlf) |The matches go out before you can burn| <x>)) + +(p name109 + (x 30) + (object ^name marijuana ^place held) + (object ^name matches ^place held) + (history ^hungry nil) + (location ^name lawn) + (input smoke marijuana) + --> + (remove 2) + (remove 3) + (remove 5) + (modify 4 ^hungry t) + (write (crlf) |You manage to light up,|) + (write (crlf) |the matches haved dried out here, this very expensive stuff.|) + (write (crlf) |Its very smooth, you begin to think you really don't|) + (write (crlf) |need to adventure anymore. You are hungry.|)) + +(p name110 + (x 30) + (object ^name marijuana ^place held) + (input smoke marijuana) + --> + (remove 3) + (write (crlf) |You don't have any matches.|)) + +(p name111 + (x 30) + (input smoke marijuana) + --> + (remove 2) + (write (crlf) |You don't have any.|)) + +(p name112 + (x 30) + (object ^name marijuana ^place held) + (object ^name matches ^place held) + (input smoke marijuana) + --> + (remove 4) + (write (crlf) |The matches are wet.|)) + +(p name113 + (x 30) + (history ^hungry t) + (object ^name <x> ^place held) + --> + (write (crlf) |I'm so hungry, I could eat a | <x> ) + (make input eat <x>)) + +(p name114 + (x 20) + (history ^hungry t) + --> + (modify 1 ^hungry nil)) + +(p name115 + (x 30) + (input <y> << maryjane marihuana dope grass pot >>) + --> + (remove 2) + (make input <y> marijuana)) + +(p name116 + (x 30) + (input << smoke light burn >> marijuana) + --> + (remove 2) + (make input smoke marijuana)) + + +(comment ***********************************CUBE*****************************) +(p name117 + (x 20) + (location ^name <x>) + (object ^name cube ^place <x>) + --> + (write (crlf) |There is a small white cube here.|)) + +(p name118 + (x 30) + (object ^name cube ^place held) + (input lick cube) + --> + (remove 3) + (write (crlf) |UHM! That tasted good!!!|)) + +(p name119 + (x 30) + (object ^name cube ^place held) + (input taste cube) + --> + (remove 3) + (write (crlf) |To taste it you should really eat the cube.|)) + +(p name120 + (x 30) + (object ^name cube ^place held) + (object ^name watch ^place held) + (input eat cube) + --> + (remove 2) + (remove 4) + (write (crlf) |The cube tastes like sugar. You are suddenly surrounded by|) + (write (crlf) |a herd of moose. They start talking to you about a moose-load of things.|) + (write (crlf) |One walks over to you and whispers, 'Fa Lowe, why her?'|) + (write (crlf) |You look at your watch , but the hands suddenly spin!|) + (write (crlf) |You find yourself staring at the|) + (write (crlf) |m|) + (write (crlf) | o|) + (write (crlf) | o|) + (write (crlf) | s|) + (write (crlf) | e|) + (write (crlf) | ?|) + (write (crlf) | for a long time, and enjoying it.|)) + +(p name121 + (x 30) + (object ^name cube ^place held) + (input eat cube) + --> + (remove 2) + (remove 3) + (write (crlf) |The cube tastes like sugar. You are suddenly surrounded by|) + (write (crlf) |a herd of moose. They start talking to you about a moose-load of things.|) + (write (crlf) |One walks over to you and whispers, 'Fa Lowe, why her?'|) + (write (crlf) |You find yourself staring at your toes|) + (write (crlf) | for a long time, and enjoying it.|)) + +(p name122 + (x 30) + (location ^name kitchen) + (object ^name cube ^place held) + (input eat cube) + --> + (remove 3) + (remove 4) + (write (crlf) |That was sweet.|) + (write (crlf) |This kitchen is real deary. A bad place to take acid.|) + (write (crlf) |You have to get out of here!!|) + (write (crlf) |You feel on fire, you need water to cool off.|) + (make input + w then push button then n then push b then exit then push red button)) + +(p name123 + (x 30) + (input <x> white cube) + --> + (remove 2) + (make input <x> cube)) + +(p name124 + (x 30) + (input <x> << sugar acid >>) + --> + (remove 2) + (make input <x> cube)) + +(comment *************************CANCER*************************************) + +(p name125 + (x 60) + (location) + (status ^likes <B>) + (time ^cancer <TIME> ^realtime <TIME>) + --> + (write (crlf) |Your wicked and lusty life has finally caught up with you.|) + (write (crlf) |That cigarette you had with the| <B> |has caused cancer to|) + (write (crlf) |spread throughout your lungs. COUGH!! COUGH!! You are|) + (write (crlf) |weakening. Hack! You're down on your knees. COUGH COUGH!!|) + (write (crlf) |You keel over and die....|) + (modify 3 ^quit t)) + + +(comment **********************Going Crazy******************************** ) + +(p name126 + (x 60) + (time ^orc_status sweat ^orc_time <x> ^realtime <x>) + --> + (modify 2 ^orc_status dizzy ^orc_time (compute <x> + 120)) + (write (crlf) | |) + (write (crlf) |You are starting to sweat. I think this place is getting to you.|)) + +(p name127 + (x 60) + (time ^orc_status dizzy ^orc_time <x> ^realtime <x>) + --> + (modify 2 ^orc_status mad ^orc_time (compute <x> + 60)) + (write (crlf) | |) + (write (crlf) |Your getting a little dizzy.|) + (write (crlf) |The area around seems to swim a little when you move.|)) + +(p name128 + (x 60) + (time ^orc_status mad ^orc_time <x> ^realtime <x>) + --> + (modify 2 ^orc_status suicide ^orc_time (compute <x> + 30)) + (write (crlf) | |) + (write (crlf) |I think you are definitely going insane. The sweaty palms and dizziness were|) + (write (crlf) |the first signs. If you don't do something quick, you'll commit suicide!|)) + +(p name129 + (x 60) + (time ^orc_status suicide ^orc_time <x> ^realtime <x>) + (status) + --> + (modify 2 ^orc_status nil ^orc_time nil) + (modify 3 ^die t) + (write (crlf) | |) + (write (crlf) |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|) + (write (crlf) |You can't stand it anymore, you are now totally crazy!|) + (write (crlf) |You start laughing uncontrollably, but choke on your tongue.|) + (write (crlf) |Ugh! Well at least you died happy!|)) + +(p name130 + (x 30) + (time ^orc_status <> nil) + (command ^string eat_it) + --> + (modify 2 ^orc_status nil) + (remove 3) + (write (crlf) |You feel much saner.|) + (write (crlf) |You've managed to avoid the St. John curse!|)) + +(p name131 + (x 30) + (time ^orc_status suicide) + (command ^string eat_it) + --> + (modify 2 ^orc_status nil) + (remove 3) + (write (crlf) |You've done it! The orchid returns you to sanity.|)) + + +(comment **********************More Random********************************* ) + +(p name132 + (x 30) + (input << examine describe >> <x>) + --> + (remove 2) + (make input look <x>)) + +(p name133 + (x 30) + (place ^name <y> ^visited t) + (location ^name <y>) + (input look) + --> + (remove 4) + (modify 2 ^visited nil)) + +(p name134 + (x 30) + (input kill) + --> + (remove 2) + (write (crlf) |With what? Your bare hands?|)) + +(p name135 + (x 30) + (object ^name <x> ^place <z>) + (location ^name <z>) + (input kill <x> with <y>) + --> + (remove 4) + (write (crlf) |Even with that you can't kill it.|)) + +(p name136 + (x 30) + (object ^name football ^holds nil) + (input throw football) + --> + (remove 3) + (write (crlf) |You don't have a football Dummy!|)) + +(p name137 + (x 30) + (input throw) + --> + (remove 2) + (write (crlf) |I don't throw anything but a regulation NFL football.|)) + +(p name138 + (x 30) + (input throw up) + --> + (remove 2) + (write (crlf) |I don't have the stomach for that.|)) + +(p name139 + (x 30) + (input cut) + --> + (remove 2) + (write (crlf) |There is nothing to cut with.|)) + +(p name140 + (x 30) + (input cut <x> with <y>) + --> + (remove 2) + (write (crlf) |The| <y> |won't cut the| <x> |.|)) + +(p name141 + (x 30) + (input cut cheese) + --> + (remove 2) + (write (crlf) |Look, this room is smelly enough already without that.|)) + +(p name142 + (x 30) + (input break <x>) + --> + (remove 2) + (write (crlf) |You hurt your hand.|)) + +(p name143 + (x 30) + (input bust bust) + --> + (remove 2) + (write (crlf) |Homer looks hurt.|)) + +(p name144 + (x 30) + (input kick <x>) + --> + (remove 2) + (write (crlf) |Ouch! The| <x> |kicks back.|)) + +(p name145 + (x 30) + (object ^name <x> ^place held) + (location ^name <y> ^side <s> ^north <n> ^east <e>) + (input kick <x>) + --> + (modify 2 ^place <y> ^side <s> ^north <n> ^east <e>) + (remove 4) + (write (crlf) |Thud! Not much of a kicker I see.|)) + +(p name146 + (x 30) + (input kick football) + --> + (remove 2) + (write (crlf) |I see no football here.|)) + +(p name147 + (x 30) + (input punt <x>) + --> + (remove 2) + (make input kick <x>)) + +(p name148 + (x 20) + (input jump) + --> + (remove 2) + (write (crlf) |Up you go, down you come.|)) + +(p name149 + (x 20) + (input burn <x>) + --> + (remove 2) + (write (crlf) |You can't burn| <x> |without matches.|)) + +(p name150 + (x 30) + (object ^name matches ^place held) + (input burn) + --> + (remove 3) + (write (crlf) |You may have matches, but you didn't light one.|)) + +(p name151 + (x 30) + (input open) + --> + (remove 2) + (write (crlf) |I don't see anything that is closed.|)) + +(p name152 + (x 30) + (input open chest) + --> + (remove 2) + (write (crlf) |The chest can't be opened, but it is worth mucho closed.|)) + +(p name153 + (x 30) + (input help) + --> + (remove 2) + (write (crlf) |Help yourself|)) + +(p name154 + (x 20) + (current ^type operator ^name process) + (input yes) + --> + (remove 3) + (write (crlf) |Cute, but lets get on with the show.|)) + +(p name155 + (x 30) + (current ^type operator ^name process) + (input no) + --> + (remove 3) + (write (crlf) |That was rhetorical you fool.|)) + +(p name156 + (x 30) + (input spit <x>) + --> + (remove 2) + (write (crlf) |Your throat is too dry.|)) + +(p name157 + (x 30) + (input where <x>) + --> + (remove 2) + (write (crlf) |I don't know where| <x> |. I hope we aren't lost!!|)) + +(p name158 + (x 30) + (input find <x>) + --> + (remove 2) + (write (crlf) |That would be cheating if I did it.|)) + +(p name159 + (x 20) + (input drink <a>) + --> + (remove 2) + (write (crlf) |The| <a> |is not drinkable.|)) + +(p name160 + (x 20) + (input drink nil) + --> + (remove 2) + (write (crlf) |I don't know what to drink.|)) + +(p name161 + (x 30) + (input screw) + --> + (remove 2) + (write (crlf) |Sorry, but i don't have a screw driver.|)) + +(p name162 + (x 30) + (input fuck) + --> + (remove 2) + (write (crlf) |That would be pretty kinky.|)) + +(p name163 + (x 30) + (input fuck bust) + --> + (remove 2) + (write (crlf) |Homer is harder than you are.|)) + +(p name164 + (x 30) + (status ^wears wetsuit) + (input fuck <x>) + --> + (remove 3) + (write (crlf) |You can't do that with a wetsuit on!|)) + +(p name165 + (x 30) + (input up yours) + --> + (remove 2) + (write (crlf) |Up your own.|)) + +(p name166 + (x 30) + (input oh shit) + --> + (remove 2) + (write (crlf) |Isn't life a pisser?|)) + +(p name167 + (x 30) + (input oh no) + --> + (remove 2) + (write (crlf) |Mais oui.|)) + +(p name168 + (x 30) + (input shit) + --> + (remove 2) + (write (crlf) |Hey, let's not mess up the place!|)) + +(p name169 + (x 30) + (input rape <x>) + --> + (remove 2) + (make input torture <x>)) + +(p name170 + (x 30) + (input kiss) + --> + (remove 2) + (write (crlf) |SMACK!|)) + +(p name171 + (x 30) + (input << ball copulate hump >> <x>) + --> + (remove 2) + (make input fuck <x>)) + +(p name172 + (x 30) + (input make love) + (status ^likes <x>) + --> + (remove 2) + (make input fuck <x>)) + +(p name173 + (x 30) + (input masturbate) + --> + (remove 2) + (write (crlf) |You're too scared to get aroused at all.|)) + +(p name174 + (x 30) + (input god damn) + --> + (remove 2) + (make input pray)) + +(p name175 + (x 30) + (input tingle) + --> + (remove 2) + (write (crlf) |Nothing happens.|)) + +(p name176 + (x 30) + (input blow) + --> + (remove 2) + (write (crlf) |Whoooooosh!|)) + +(p name177 + (x 20) + (input knock) + --> + (remove 2) + (write (crlf) |Thud, thud.|)) + +(p name178 + (x 30) + (input eat <> orchid) + --> + (remove 2) + (write (crlf) |That is not part of a balanced diet.|)) + +(p name179 + (x 30) + (object ^name <x> ^holds nil) + (input eat <x>) + --> + (remove 3) + (write (crlf) |You don't have| <x> |on you.|)) + +(p name180 + (x 30) + (input eat shit) + --> + (remove 2) + (write (crlf) |YEACH! Fuck off!|)) + +(p name181 + (x 30) + (status) + (input go to hell) + --> + (remove 3) + (write (crlf) |Oh yeah! I'm fed up with you!!|) + (modify 2 ^quit t)) + +(p name182 + (x 30) + (input <x> moose) + --> + (remove 2) + (write (crlf) |I see no moose.|)) + +(p name183 + (x 30) + (input go blue) + --> + (remove 2) + (write (crlf) |Beat State.|)) + +(p name184 + (x 30) + (input pray) + --> + (remove 2) + (write (crlf) |GOD responds:|) + (make input help)) + +(p name185 + (x 30) + (input damn <x>) + --> + (remove 2) + (write (crlf) |Clean up your act.|)) + + +(p name186 + (x 30) + (input open sesame) + --> + (remove 2) + (write (crlf) |No says me!|)) + +(p name187 + (x 30) + (input I <x>) + --> + (remove 2) + (write (crlf) |Quit talking about yourself and give me a command.|)) + +(p name188 + (x 20) + (input give <x> to <y>) + --> + (remove 2) + (write (crlf) |The| <y> |doesn't take| <x> )) + +(p name189 + (x 20) + (input give <x> <y>) + --> + (remove 2) + (write (crlf) |The| <x> |doesn't want| <y> )) + +(p name190 + (x 30) + (object ^name <x> ^place held) + (input give <x>) + --> + (remove 3) + (write (crlf) |Hey, after we went through all the trouble to get | + (crlf) <x> |I ain't gonna let you give it away.|)) + +(p name191 + (x 20) + (input give <x>) + --> + (remove 2) + (write (crlf) |First we should get it.|)) + +(p name192 + (x 30) + (time ^realtime 0002) + (input follow moose) + --> + (remove 3) + (write (crlf) |Crash!! Into the wall you go.|)) + +(p name193 + (x 30) + (location ^name bus_stop) + (time ^realtime 0002) + (input follow moose) + --> + (remove 4) + (write (crlf) |Last I saw he went west, so away we go.|) + (make input west)) + +(p name194 + (x 30) + (input follow moose) + --> + (remove 2) + (write (crlf) |I see no moose here.|)) + +(p name195 + (x 30) + (input swim) + --> + (remove 2) + (write (crlf) |Why don't you wait until we are in the water.|)) + + +(comment **************Get on and off objects ****************************** ) + +(p name196 + (x 30) + (status) + (input mount) + --> + (remove 3) + (modify 2 ^going u ^went u)) + +(p name197 + (x 30) + (input stand on) + --> + (remove 2) + (make input mount)) + +(p name198 + (x 20) + (input get on) + --> + (remove 2) + (make input mount)) + +(p name199 + (x 30) + (input climb on) + --> + (remove 2) + (make input mount)) + +(p name200 + (x 30) + (status) + (input climb) + --> + (remove 3) + (modify 2 ^going u ^went u)) + +(p name201 + (x 30) + (location ^name <> bus) + (status) + (input get off) + --> + (remove 4) + (modify 3 ^going d ^went d)) + +(p name202 + (x 30) + (status) + (input get down) + --> + (remove 3) + (modify 2 ^going d ^went d)) + +(p name203 + (x 30) + (status) + (input dismount) + --> + (remove 3) + (modify 2 ^going d ^went d)) + +(p name204 + (x 30) + (input sit in) + --> + (remove 2) + (make input sit on)) + +(p name205 + (x 30) + (input sit) + --> + (remove 2) + (write (crlf) |I don't know how to sit on it.|)) + +(p name206 + (x 50) + (location ^ontop <> nil ^going d) + --> + (modify 2 ^ontop nil ^going nil) + (write (crlf) |You are back on Terra Firma.|)) + +(p name207 + (x 40) + (location ^ontop <> nil ^going <> nil) + --> + (modify 2 ^ontop nil ^going nil) + (write (crlf) |You just fell to the ground.|) + (make input look)) + +(p name208 + (x 40) + (location ^siton <> nil ^going <> nil) + --> + (modify 2 ^siton nil)) + +(p name209 + (x 30) + (location ^siton <> nil) + (input get up) + --> + (modify 2 ^siton nil) + (remove 3) + (write (crlf) |You are now standing.|)) + +(p name210 + (x 30) + (location siton <> nil) + (input stand <x>) + --> + (modify 2 ^siton nil) + (remove 3) + (write (crlf) |You are no longer sitting.|)) + +(p name211 + (x 30) + (location ^siton <Q>) + (input get <Q>) + --> + (remove 3) + (write (crlf) |You'll have to stand up first.|)) + +(p name212 + (x 30) + (location ^ontop <Q>) + (input get <Q>) + --> + (remove 3) + (write (crlf) |Cute, why don't you get off it first.|)) + +(p name213 + (x 30) + (object ^name <x> ^place held) + (input mount <x>) + --> + (remove 3) + (write (crlf) |Why don't you drop it first.|)) + + +(comment *****Touchy Feelie*************************************************) + +(p name214 + (x 30) + (input << fondle cuddle hug rub tap feel >>) + --> + (remove 2) + (make input touch)) + +(p name215 + (x 30) + (object ^name <x> ^place held) + (input touch <x>) + --> + (remove 3) + (write (crlf) |It is in your hands, and it feels like a| <x> |.|)) + +(p name216 + (x 30) + (input touch wall) + --> + (remove 2) + (write (crlf) |Surprize! The wall is flat and cold.|)) + +(p name217 + (x 30) + (object ^name painting ^place held) + (input touch painting) + --> + (remove 3) + (write (crlf) |The painting is still wet!!|)) + +(p name218 + (x 30) + (input touch) + --> + (remove 2) + (write (crlf) |You should get it first.|)) + + +(comment ********************Bottle*********************************** ) +(p name219 + (x 30) + (object ^name bottle ^place held) + (history ^grave_status2 oil) + (location ^name lawn ^side in ^east 8 ^north 8) + (input fill bottle) + --> + (remove 5) + (write (crlf) |The oil won't go into the bottle, sorry.|)) + +(p name220 + (x 30) + (history ^grave_status2 oil) + (object ^name bottle ^place held) + (location ^name lawn ^side in ^east 8 ^north 8) + (input get oil) + --> + (remove 5) + (write (crlf) |The oil is too thick to go into the bottle.|)) + +(p name221 + (x 20) + (location ^name <x>) + (object ^name bottle ^place <x>) +-(object ^inside bottle) +--> + (write (crlf) |There is an empty bottle here.|)) + +(p name222 + (x 20) + (location ^name <x>) + (object ^name bottle ^place <x>) + (object ^name <q> ^inside bottle) +--> + (write (crlf) |There is a bottle of| <q> |here.|)) + +(p name223 + (x 30) + (object ^name <q> ^inside bottle) + (object ^name bottle ^place <x>) + (location ^name <x>) + (input get <q>) + --> + (modify 2 ^place held) + (remove 5) + (write (crlf) |You are now holding the bottle.|)) + +(p name224 + (x 30) + (object ^name bottle ^place held) + (location ^name bathroom) + (input fill bottle <g>) +-(object ^inside bottle) + --> + (remove 4) + (make object ^name bathwater ^inside bottle) + (write (crlf) |The bottle is full of bathwater.|)) + +(p name225 + (x 30) + (object ^name bottle ^place held) + (location ^name beach ^east 3) + (input fill bottle <g>) +-(object ^inside bottle) + --> + (remove 4) + (make object ^name water ^inside bottle) + (write (crlf) |The bottle is full of sparkling water.|)) + +(p name226 + (x 30) + (object ^name bottle ^place held) + (object ^inside bottle) + (location ^name beach ^east 3) + (input pour) + --> + (remove 3) + (remove 5) + (write (crlf) |The bottle is empty. The liquid disappears in the sand.|)) + +(p name227 + (x 30) + (object ^name bottle ^place held) + (object ^inside bottle) + (location ^name bathroom) + (input pour) + --> + (remove 3) + (remove 5) + (write (crlf) |The bottle is now empty.|)) +(comment ++++++++++++++++) +(p name228 + (location ^underwater t) + (object ^name bottle ^place held) + (input fill bottle) +-(object ^name <> nil ^inside bottle) + --> + (remove 3) + (make object ^name seawater ^inside bottle) + (write (crlf) |The bottle is full of seawater.|)) + +(p name229 + (input get << seawater bathwater water >>) + --> + (remove 1) + (make input fill bottle)) + +(p name230 + (input fill up) + --> + (remove 1) + (make input fill bottle)) + +(p name231 + (object ^name bottle ^place held) + (input fill bottle <g>) +-(object ^name <q> ^inside bottle) + --> + (remove 2) + (write (crlf) |There is nothing to fill the bottle with.|)) + +(p name232 + (object ^name bottle ^place held) + (object ^inside bottle) + (input fill bottle) + --> + (remove 3) + (write (crlf) |The bottle is already full.|)) + +(p name233 + (input fill bottle) + --> + (remove 1) + (write (crlf) |You don't have a bottle to fill.|)) + +(p name234 + (input pour) + (location ^underwater t) + --> + (remove 1) + (write (crlf) |Hmm, you want me to empty a bottle underwater.|) + (write (crlf) |I'm afraid that is out of my league.|)) + +(p name235 + (object ^name water ^place <x>) + (location ^name <x>) + --> + (write (crlf) |There is a wet spot here.|)) + +(p name236 + (object ^name seawater ^place <x>) + (location ^name <x>) + --> + (write (crlf) |There is a salty wet spot here.|)) + +(p name237 + (location ^name <x>) + (object ^name bathwater ^place <x>) + --> + (write (crlf) |There is a bit of a wet spot here.|)) + +(p name238 + (location ^name <x>) + (object ^name turpentine ^place <x>) + --> + (remove 2) + (write (crlf) |The turpentine evaporates as it leaves the bottle.|)) + +(p name239 + (location ^name <y>) + (object ^name bottle ^place held) + (object ^name <q> ^inside bottle) + (input drop <q>) + --> + (modify 2 ^place <y>) + (remove 4)) + +(p name240 + (location ^name <y>) + (object ^name bottle ^place held) + (object ^name <q> ^inside bottle) + (input pour) + --> + (remove 4) + (modify 3 ^inside nil ^place <y>)) + +(p name241 + (location ^name <x>) + (object ^name << water seawater bathwater >> ^place <x>) + (input fill bottle) + --> + (remove 3) + (write (crlf) |Sorry, I don't have a mop!|)) + +(p name242 + (location ^name <x>) + (object ^name water ^inside bottle) + (object ^name bottle ^place held) + (input drink water) + (status) + --> + (remove 1) + (remove 2) + (remove 4) + (write (crlf) |You have changed into a baby, the adventure must end.|) + (modify 5 ^quit t)) + +(p name243 + (object ^name bottle ^place held) + (object ^name seawater ^inside bottle) + (input drink) + --> + (remove 2) + (remove 3) + (write (crlf) |Yech! It tastes salty!!|)) + +(p name244 + (input << water empty >>) + --> + (remove 1) + (make input pour)) + + +(comment ********************MATCHES************************************* ) + +(p name245 + (location ^name <x>) + (object ^name matches ^place <x>) + --> + (write (crlf) |There are matches here.|)) + +(p name246 + (object ^name matches ^place held) + (input <x> match) + --> + (remove 2) + (make input <x> matches)) + +(p name247 + (object ^name matches ^place held) + (input << light strike dry >> matches) + --> + (remove 2) + (write (crlf) |This house is to damp to light the matches in.|)) + +(p name248 + (location ^name lawn) + (object ^name matches ^place held) + (input dry matches) + --> + (remove 3) + (write (crlf) |The matches dry out.|)) + +(p name249 + (location ^name lawn) + (object ^name matches ^place held) + (input << light strike >> matches) + --> + (remove 3) + (write (crlf) |The match lights but goes out quickly.|)) + +(p name250 + (input smoke <x>) + (object ^name <x> ^place <> holds) + --> + (remove 1) + (write (crlf) |You're not holding it.|)) + +(p name251 + (input light marijuana <x>) + --> + (remove 1) + (make input smoke marijuana)) + + +(comment *******************FOOTBALL****************************************) + +(p name252 + (location ^name <x>) + (object ^name football ^place <x>) + --> + (write (crlf) |There is an official NFL football here!|)) + +(p name253 + (location ^name <x>) + (object ^name football ^place held) + (input kick football) + --> + (remove 3) + (write (crlf) |Oh wow! You kick it around,|) + (write (crlf) |luckily nothing breaks.|) + (modify 2 ^place <x>)) + +(p name254 + (location ^name <x>) + (object ^name football ^place held) + (input throw football) + --> + (remove 3) + (write (crlf) |Throw is short. Incomplete pass. Fourth down, 10 to go.|) + (modify 2 ^place <x>)) + +(p name255 + (input <x> ball) + --> + (remove 1) + (make input <x> football)) + + +(comment ***************************TIME************************************ ) +(p name256 + (input what time) + (object ^name watch ^place held) + (time ^realtime <x>) + --> + (remove 1) + (write (crlf) |The time is| <x>)) + +(p name257 + (location ^name <x>) + (object ^name watch ^place <x>) + --> + (write (crlf) |There's a watch here, it even has a luminous dial.|)) + +(p name258 + (input time) + --> + (remove 1) + (make input what time)) + +(p name259 + (input read watch) + --> + (remove 1) + (make input what time)) + +(p name260 + (input tell time) + --> + (remove 1) + (make input what time)) + +(p name261 + (x 10) + (input what time) + --> + (remove 2) + (write (crlf) |I have no watch.|)) + +(p name262 + (input look at watch) + --> + (remove 1) + (make input what time)) + +(p name263 + (input put on watch) + --> + (remove 1) + (make input get watch)) + +(p name264 + (input wind watch) + --> + (remove 1) + (write (crlf) |The watch is electric.|)) + +(p name265 + (input open watch) + --> + (remove 1) + (write (crlf) |The watch is sealed shut.|)) + +(p name266 + (input break watch) + --> + (remove 1) + (write (crlf) |The watch is shock resistent too. It still works.|)) + +(p name267 + (time ^realtime 0600 ^morning nil) + --> + (modify 1 ^morning t) + (write (crlf) |'Cock-a-doodle-do'. You hear a rooster crow.|)) + +(p name268 + (time ^realtime 2000 ^morning t) + --> + (modify 1 ^morning nil) + (write (crlf) |'Clunk!' I think night just fell.|)) + +(p name269 + (time ^realtime 0000 ^midnight nil) + --> + (modify 1 ^midnight t)) + +(p name270 + (time ^midnight t) + --> + (modify 1 ^midnight nil) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |A moose comes running out of a wall at full speed straight at you!!!|) + (write (crlf) |He is right on top of you!!! He runs right through you and disappears.|)) + +(p name271 + (time ^midnight t) + (location ^name lawn) + --> + (modify 1 ^midnight nil) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |A moose comes running across the lawn at full speed straight at you!!!|) + (write (crlf) |He is right on top of you. He runs right through you and disappears.|)) + + +(p name272 + (time ^midnight t) + (location ^underwater t) + --> + (remove 1) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |BonG!|) + (write (crlf) |A moose comes swimming out of the darkness, at full speed straight at you.|) + (write (crlf) |He has on full scuba gear, and is really moving.|) + (write (crlf) |He is right on top of you. He runs right through you and disappears.|)) + + +(comment **************************PAINTING***************************) + +(p name273 + (input <x> art <y>) + --> + (remove 1) + (make input <x> painting <y>)) + +(p name274 + (location ^name <x>) + (object ^name painting ^place <x> ^covered t) + --> + (write (crlf) |There is a work of ugly modern art on the ground.|)) + +(p name275 + (location ^name <x>) + (object ^name painting ^place <x> ^covered nil) + --> + (write (crlf) |There is a valuable Rembrandt here.|)) + +(p name276 + (object ^name painting ^place held ^covered t) + (object ^name bottle ^place held) + (object ^name turpentine ^inside bottle) + (input << clean pour >>) + --> + (modify 1 ^covered nil ^treasure t) + (remove 3) + (remove 4) + (write (crlf) |The ugly paint comes off! Underneath is a Rembrandt|) + (write (crlf) |This will be very valuable.|) + (write (crlf) |It is a person and a bust in the painting.|)) + +(p name277 + (location ^name <x>) + (object ^name painting ^place <x> ^covered t) + (object ^name bottle ^place held) + (object ^name turpentine ^inside bottle) + (input << clean pour >>) + --> + (modify 2 ^covered nil ^treasure t) + (remove 4) + (remove 5) + (write (crlf) |The turpentine hits the painting and causes the paint to come off.|) + (write (crlf) |The painting has a person contemplating a bust.|)) + +(p name278 + (input remove paint) + --> + (remove 1) + (make input clean)) + +(p name279 + (object ^name painting ^place held ^covered t) + --> + (write (crlf) |Upon closer look, this is worthless!|)) + + +(comment *******************Money************************************* ) + +(p name280 + (location ^name <x>) + (object ^name money ^place <x>) + --> + (write (crlf) |The money is here!|)) + +(comment *******************Stereo************************************* ) + +(p name281 + (location ^name smelly_room) + (object ^name stereo ^place held) + (status ^sound on) + --> + (modify 3 ^sound off)) + +(p name282 + (object ^name stereo ^place smelly_room) + (location ^name smelly_room) + (status ^sound on) + (input turn off) + --> + (modify 3 ^sound off) + (remove 4) + (write (crlf) |The stereo is off. But you broke it, so it won't turn on.|)) + +(p name283 + (location ^name <x>) + (object ^name stereo ^place <x>) + --> + (write (crlf) |There is an expensive stereo here, worth many megabucks!!|)) + + +(comment *******************Book****************************** ) + +(p name284 + (location ^name <x>) + (object ^name book ^place <x>) + --> + (write (crlf) |There is a book on the ground.|)) + +(p name285 + (object ^name book ^place held) + (input read book) + --> + (remove 2) + (write (crlf) |Vampires can only be destroyed by a stake through the heart,|) + (write (crlf) |or by the light of day. They are invunerable to all other|) + (write (crlf) |attacks. They dislike garlic and fear crosses. They are known|) + (write (crlf) | to frequent dark rooms.|)) + +(comment ************************GOLD************************) + +(p name286 + (location ^name <x>) + (object ^name gold ^place <x>) + --> + (write (crlf) |There is gold here.|)) + + +(comment ************************HORN************************) + +(p name287 + (location ^name <x>) + (object ^name horn ^place <x>) + --> + (write (crlf) |There is a magic unicorn horn here.|)) + +(p name288 + (location ^name <x>) + (object ^name horn ^place <x>) + (object ^name horn ^place held) + (input drop horn) + --> + (remove 3) + (remove 4) + (write (crlf) |When you drop the horn, it and the one on the ground merge together.|)) + +(p name289 + (location ^name dining_room ^ontop stool) + (object ^name horn ^place held) + (input get horn) + --> + (remove 3) + (write (crlf) |The horn won't come off.|)) + +(p name290 + (object ^name horn ^place held) + (input blow horn) + (history ^clue nil) + --> + (remove 1) + (remove 2) + (write (crlf) |A terrific noise comes from the horn. BLAT!!!|) + (write (crlf) |The horn disappears from your hands.|) + (write (crlf) |Your body shakes and you black out ......|) + (modify 3 ^clue t)) + +(p name291 + (history ^clue t ^grave_status undug) + --> + (write (crlf) |A spirit appears to you in your sleep.|) + (write (crlf) |Your mind is filled with the following phrase:|) + (write (crlf) |'As your family is sheep, the gold that is YOUR color must be found|) + (write (crlf) |before you can escape this estate.' |) + (modify 1 ^clue nil)) + +(p name292 + (history ^clue t) + --> + (modify 1 ^clue nil) + (write (crlf) |When you wake you see smoke form the words:|) + (write (crlf) |EVERY OPTIon on A MACHINE HAS A PURPOSE. The smoke then dissapates.|)) + +(p name293 + (history ^clue t) + (object ^name orchid ^place lawn) + --> + (write (crlf) |You dream of a garden of flowers.|) + (modify 1 ^clue nil)) + +(comment ************************Candlesticks************************) + +(p name294 + (input <x> them) + --> + (remove 1) + (make input <x> candlesticks)) + +(p name295 + (location ^name <x>) + (object ^name candlesticks ^place <x>) + --> + (write (crlf) |There is a pair of silver candlesticks here!! No candles though.|)) + +(p name296 + (object ^name candlesticks ^place held) + (input form cross) + --> + (modify 1 ^state crossed) + (remove 2) + (write (crlf) |The candlesticks are in a cross.|)) + +(p name297 + (object ^name candlesticks ^place held) + (input make cross) + --> + (modify 1 ^state crossed) + (remove 2) + (write (crlf) |The candlesticks are in a cross.|)) + +(p name298 + (location ^name <x>) + (object ^name candlesticks ^place held ^state crossed) + (input drop candlesticks) + --> + (modify 2 ^place <x> ^state nil) + (remove 3)) + +(p name299 + (input << make form >> cross) + --> + (remove 1) + (write (crlf) |You have nothing to form a cross with, arms don't work.|)) + +(p name300 + (input cross candlesticks) + --> + (remove 1) + (make input make cross)) + +(comment *********************CHAIR*************************************) +(p name301 + (location ^name <x>) + (object ^name chair ^place <x>) + --> + (write (crlf) |There is an old style chair on the ground.|)) + +(p name302 + (object ^name chair ^place held) + --> + (write (crlf) |The plate of the back of the chair says 'MADE BY LOUIS XIV'|)) + +(p name303 + (location ^name <x>) + (object ^name chair ^place <x>) + (input mount chair) + --> + (remove 2) + (remove 3) + (write (crlf) |The priceless chair breaks under your weight.|) + (write (crlf) |It then disappears.|)) + +(p name304 + (location ^name <x>) + (object ^name chair ^place <x>) + (input sit on chair) + --> + (remove 2) + (remove 3) + (write (crlf) |You sat on the chair and it broke!|) + (write (crlf) |It disappears.|)) + + +(comment **********************STOOL*************************************) + +(p name305 + (location ^name <x>) + (object ^name stool ^place <x>) + --> + (write (crlf) |There is a sturdy stool here.|)) + +(p name306 + (location ^name <x>) + (object ^name stool ^place <x>) + (input sit) + --> + (remove 3) + (modify 1 ^siton stool) + (write (crlf) |You're sitting on the stool.|)) + +(p name307 + (object ^name stool ^place held) + (input sit) + --> + (remove 2) + (write (crlf) |I suggest you drop the stool first.|)) + +(p name308 + (location ^name <x>) + (object ^name stool ^place <x>) + (input mount stool) + --> + (modify 1 ^siton stool) + (remove 3) + (write (crlf) |You are on the stool.|)) + +(p name309 + (input climb stool) + --> + (remove 1) + (make input mount stool)) + +(comment ****************Additional objects********************) + +(comment ****Chest**** ) + +(p name310 + (location ^name <x>) + (object ^name chest ^place <x>) + --> + (write (crlf) |There is a chest of treasure!!!|)) + +(p name311 + (object ^name chest ^place held) + (input open chest) + --> + (remove 2) + (write (crlf) |Give up, the chest doesn't open, but is worth gigabucks the way it is.|)) + +(comment ****Conch**** ) + +(p name312 + (object ^name conch ^place held) + (input blow conch) + --> + (remove 2) + (write (crlf) |'Hoooonk!'|)) + +(p name313 + (object ^name conch ^place <x>) + (location ^name <x>) + --> + (write (crlf) |There is a large conch shell here.|)) + +(p name314 + (input <x> shell) + --> + (remove 1) + (make input <x> conch)) + +(p name315 + (object ^name conch ^place held) + (input listen conch) + --> + (remove 1) + (write (crlf) |You hear the ocean 'rumble'.|)) + +(p name316 + (location ^name <x>) + (object ^name token ^place <x>) + --> + (write (crlf) |There is a token here.|)) + +(p name317 + (location ^name <x>) + (object ^name tokens ^place <x>) + --> + (write (crlf) |There are tokens here.|)) + +(p name318 + (input bite <x>) + (object ^name <x> ^place held) + --> + (remove 1) + (write (crlf) |The| <x> |bites back, Chomp!!|)) + +(p name319 + (x 10) + (input bite) + --> + (remove 2) + (write (crlf) |You must be holding what you are trying to bite.|)) + +(p name0320 + (object ^name <x> ^treasure t ^place held ^scored nil) + (status ^score <y>) + --> + (modify 2 ^score (compute <y> + 15)) + (modify 1 ^scored t)) + +(p name0321 + (object ^name bottle ^place lawn) + (object ^name water ^inside bottle ^xscore nil) + (status ^score <y>) + --> + (modify 3 ^score (compute 5 + <y>)) + (modify 2 ^xscore t)) + +(p name0322 + (input pour) + (object ^name bottle ^place held) + (object ^name water ^xscore t) + (status ^score <z>) + --> + (remove 1) + (modify 4 ^score (compute <z> - 5))) + +(p name0323 + (object ^name <x> ^place lawn ^treasure t ^xscore nil) + (status ^score <y>) + --> + (modify 2 ^score (compute 5 + <y>)) + (modify 1 ^name <x> ^xscore t)) + +(p name0324 + (object ^name <x> ^xscore t ^place held) + (status ^score <y>) + --> + (modify 1 ^xscore nil) + (modify 2 ^score (compute <y> - 5))) + +(p name321 + (input score) + (status ^score <x>) + --> + (write (crlf) |Score =| <x>) + (remove 1)) + +(p name322 + (status ^quit t ^score <x>) + --> + (write (crlf) |Your final score is| <x>) + (write (crlf) |The total possible is 440|) + (make turnoff)) + +(p name323 + (turnoff) + (status ^score < 20) + --> + (write (crlf) |Hmm... I don't think you tried very hard.|)) + +(p name324 + (turnoff) + --> + (halt)) + +(p name325 + (turnoff) + (status ^score {< 50 > 21}) + --> + (write (crlf) |Rank Novice! Are you scared of your own shadow?|)) + +(p name326 + (turnoff) + (status ^score {> 51 < 80}) + --> + (write (crlf) |Beginning Ghost Hunter|)) + +(p name327 + (turnoff) + (status ^score {> 81 < 140}) + --> + (write (crlf) |Reasonable Spirit Fighter|)) + +(p name328 + (turnoff) + (status ^score {> 141 < 220}) + --> + (write (crlf) |Intermediate Haunt Hacker|)) + +(p name329 + (turnoff) + (status ^score {> 221 < 290}) + --> + (write (crlf) |Advanced Monster Killer|)) + +(p name330 + (turnoff) + (status ^score {> 291 < 360}) + --> + (write (crlf) |Master Haunter!!|)) + +(p name331 + (turnoff) + (status ^score > 361) + --> + (write (crlf) |Fearless Vampire Killer|)) + +(p name332 + (status ^likes <x>) + (turnoff) + (status ^score > 435) + --> + (write (crlf) |and waster of many cycles.|)) + +(p name333 + (location ^name <x>) + (object ^name pearls ^place <x>) + --> + (write (crlf) |There are huge pearls here!!|)) + +(p name334 + (location ^name <x>) + (object ^name diamonds ^place <x>) + --> + (write (crlf) |There are diamonds here!|)) + +(p name335 + (location ^name <x>) + (object ^name orchid ^place <x> ^state plant) + --> + (write (crlf) |There is a beautiful black orchid here.|)) + +(p name336 + (location ^name <x>) + (object ^name orchid ^place <x> ^state plant) + (input smell <y>) + --> + (remove 3) + (write (crlf) |Yum! The orchid smells delicious!|)) + +(p name337 + (object ^name orchid ^place held) + (input smell orchid) + --> + (remove 2) + (write (crlf) |I like the odor! Sniff. Sniff.|)) + +(p name338 + (input pick orchid) + --> + (remove 1) + (make input get orchid)) + +(p name339 + (input smell <x>) + --> + (remove 1) + (write (crlf) |Ah CHOOOO! There is alot of dust around here.|)) + +(p name340 + (input sniff <x>) + --> + (remove 1) + (make input smell <x>)) + +(p name341 + (location ^name <x>) + (object ^name rope ^place <x> ^tied noose) + --> + (write (crlf) |There is rope in a noose here.|)) + +(p name342 + (location ^name <x>) + (object ^name rope ^place <x> ^tied untied) + --> + (write (crlf) |There is some loose rope here.|)) + +(p name343 + (location ^name <x>) + (object ^name <y> ^place <x>) + (object ^name rope ^place <> <x> ^tied <y>) + --> + (write (crlf) |A rope is tied to the| <y> )) + +(p name344 + (location ^name <x>) + (object ^name <y> ^place <> <x>) + (object ^name rope ^place <x> ^tied <y>) + --> + (write (crlf) |An end of a rope is here.|)) + +(p name345 + (location ^name <x>) + (object ^name rope ^place <x> ^tied <y>) + (object ^name <y> ^place <x>) +--> + (write (crlf) |An end of the rope is here, tied to the | <y> )) + +(p name346 + (location ^name <x>) + (object ^name rope ^place <x> ^tied <y>) + (object ^name <y> ^place held) +--> + (write (crlf) |A rope tied to the| <y> |is here.|)) + +(p name347 + (object ^name rope ^place held ^tied noose) + (input untie rope) + --> + (modify 1 ^tied untied) + (remove 2) + (write (crlf) |The rope is now untied.|)) + +(p name348 + (object ^name rope ^tied noose) + (input hang <x>) + --> + (remove 2) + (write (crlf) |No hanging around here.|)) + +(p name349 + (object ^name rope ^place held ^tied noose) + (input tie rope <x>) + --> + (remove 2) + (write (crlf) |The rope is already in knots.|)) + +(p name350 + (object ^name rope ^place held) + (input tie <x>) + --> + (remove 2) + (write (crlf) |Look, don't tie| <x> |, tie rope to something you have on you.|)) + +(p name351 + (object ^name rope ^place held) + (input tieup <x>) + --> + (remove 2) + (make input tie rope to <x>)) + +(p name352 + (object ^name rope ^place held ^tied untied) + (object ^name <x> ^place held) + (input tie rope to <x>) + --> + (modify 1 ^tied <x>) + (remove 3) + (write (crlf) |The rope is tied to| <x> |.|)) + +(p name353 + (object ^name rope ^place held ^tied <z>) + (input tie rope to <x>) + --> + (remove 2) + (write (crlf) |The rope is already tied to the| <z> ) + (write (crlf) |I can tie the rope to only one object at a time.|)) + +(p name354 + (location ^name <y>) + (object ^name <x> ^place <y>) + (object ^name rope ^place <> held ^tied <x>) + (input get <x>) + --> + (modify 3 ^place held) + (write (crlf) |You get the rope first and then ...|)) + +(p name355 + (location ^name <y>) + (object ^name <x> ^place held) + (object ^name rope ^place <> held ^tied <x>) + (input get rope) + --> + (modify 3 ^place held) + (remove 4) + (write (crlf) |You just pulled in the rest of the rope.|)) + +(p name356 + (location ^name <Z>) + (object ^name rope ^place held) + (object ^name cecil ^place <Z>) + (input tie rope to cecil) + --> + (remove 4) + (write (crlf) |You can't tie cecil down!|)) + +(p name357 + (location ^name laboratory) + (object ^name rope ^place held) + (input tie rope to monster) + --> + (remove 3) + (write (crlf) |That would be very foolish.|)) + +(p name358 + (location ^name <Z>) + (object ^name rope ^place held ^tied untied) + (object ^name dracula ^place <Z>) + (input tie rope to dracula) + --> + (remove 4) + (write (crlf) |You can't get Dracula, not to mention tie him up.|)) + +(p name359 + (input tie rope to {<< candy marijuana cube orchid >> <x>} ) + (object ^name rope ^place held ^tied untied) + (object ^name <x> ^place held) + --> + (remove 1) + (write (crlf) |That is too small for the rope to be tied to.|)) + +(p name360 + (input lasso <x>) + --> + (remove 1) + (make input tie rope to <x>)) + +(p name361 + (object ^name rope ^place held ^tied untied) + (input tie rope to rope) + --> + (modify 1 ^tied noose) + (remove 2) + (write (crlf) |The rope is tied in knots.|)) + +(p name362 + (location ^name torture_chamber) + (status ^likes <x>) + (object ^name rope ^place held) + (object ^name damsel ^state free) + (input tie rope to <x>) + --> + (remove 5) + (make input torture damsel)) + +(p name363 + (location ^name <x>) + (object ^name rope ^place held) + (object ^name chest ^place <x>) + (object ^name octopus ^alive t) + (input tie rope to chest) + --> + (remove 5) + (write (crlf) |The octopus blocks your way.|)) + +(p name364 + (object ^name rope ^place held) + (input tie rope to <x>) + --> + (remove 2) + (write (crlf) |Either you aren't holding | <x> |, or I can't tie the rope to it.|)) + +(p name365 + (object ^name rope ^place <> held) + (input tie rope to <z>) + --> + (remove 2) + (write (crlf) |You don't have the rope.|)) + +(p name366 + (input untie rope) + (object ^name rope ^tied <x>) + (object ^name <x> ^place held) +--> + (remove 1) + (modify 2 ^tied untied) + (write (crlf) |The rope is no longer tied to| <x> |.|)) + +(p name367 + (input pull rope) + (object ^name rope ^place held ^tied <x>) + (object ^name <x>) +--> + (write (crlf) |Umph! You just pulled in the| <x> |.|) + (remove 1) + (modify 3 ^place held)) + +(p name368x5 + (input pull rope) + (object ^name rope ^tied <x>) + (object ^name <x> ^place held) + --> + (remove 1) + (modify 2 ^place held) + (write (crlf) |You now have all the rope.|)) + +(p name368 + (input untie rope) + (object ^name rope ^tied untied) + --> + (remove 1) + (write (crlf) |The rope isn't tied to anything.|)) + +(p name369 + (input untie rope) + (object ^name rope ^tied <x>) + (object ^name <x> ^place <y>) + --> + (remove 1) + (write (crlf) |The rope is tied to the| <x> |, which you aren't holding.|)) + +(p name370 + (location ^name bathysphere) + (input pull rope) + (object ^name rope ^tied <x>) + (object ^name <x> ^place ocean) + (portal ^name wdoor ^door closed) + --> + (remove 2) + (write (crlf) |The airlock door is closed on the rope.|)) + +(p name371 + (location ^name <x>) + (object ^name wetsuit ^place <x>) + --> + (write (crlf) |There is a wetsuit, with everything needed to survive (location ^underwater t).|)) + +(p name372 + (input << don wear >> <x>) + --> + (remove 1) + (make input put on <x>)) + +(p name373 + (location ^name <x>) + (object ^name wetsuit ^place <x>) + (input put on wetsuit) + --> + (modify 2 ^place held)) + +(p name374 + (object ^name wetsuit ^place held) + (input put on wetsuit) + --> + (modify 1 ^wears t) + (remove 2) + (write (crlf) |You are wearing a wetsuit.|)) + +(p name375 + (object ^name wetsuit ^wears t) + (input << remove doff >> wetsuit) +--> + (modify 1 ^wears nil) + (remove 2) + (write (crlf) |Your wetsuit is in your arms.|)) + +(p name376 + (location ^name <x>) + (input drop wetsuit) + (object ^name wetsuit ^place held ^wears t) + --> + (remove 2) + (modify 3 ^wears nil ^place <x>)) + +(p name377 + (location ^name <x>) + (object ^name speargun ^place <x>) + --> + (write (crlf) |There is a speargun that shoots underwater.|)) + +(p name378 + (location ^name <x>) + (object ^name speargun ^place <x> ^state loaded) +--> + (write (crlf) |The speargun is loaded, ready to fire.|)) + +(p name379 + (location ^name <x>) + (object ^name speargun ^place held ^state loaded) + (location ^underwater nil) + (input shoot) + (status) + --> + (modify 2 ^state unloaded) + (remove 4) + (write (crlf) |The gun goes off. BRRRANG!!|) + (write (crlf) |The backlash from the speargun snaps your neck!|) + (modify 5 ^quit t)) + +(p name380 + (object ^name speargun ^place held ^state unloaded) + (input shoot speargun) + --> + (remove 2) + (write (crlf) |The gun isn't loaded with a spear!|)) + +(p name381 + (object ^name speargun ^place held ^state unloaded) + (object ^name spear ^place held) + (input load) + --> + (write (crlf) |The gun is now loaded.|) + (modify 1 ^state loaded)) + +(p name382 + (location ^name <x>) + (object ^name spear ^place <x>) + --> + (write (crlf) |There is a speargun spear here.|)) + +(p name383 + (input <x> gun) + --> + (remove 1) + (make input <x> speargun)) + +(p name384 + (input << pres p depress push >> <x>) + --> + (remove 1) + (make input press <x>)) + +(p name385 + (location ^name <x>) + (object ^name coins ^place <x>) + --> + (write (crlf) |You see many coins here!|)) + +(p name386 + (location ^name <x>) + (object ^name bone ^place <x>) + --> + (write (crlf) |There is a bone here that you identify as from the MISSING LINK!|)) + +(p name387 + (location ^name <x>) + (object ^name soap ^place <x>) + --> + (write (crlf) |There is a bar of soap here.|)) + +(p name388 + (location ^name <x>) + (object ^name gem ^place <x>) + --> + (write (crlf) |There is a valuable gem here.|)) + +(p name396 + (location ^name <x>) + (object ^name jade ^place <x>) + --> + (write (crlf) |There is a piece of valuable jade here.|)) + +(p name397 + (input why <x>) + --> + (remove 1) + (write (crlf) |Hey, I don't know.|) + (write (crlf) |Send mail to Laird@cmua if you have questions.|)) + +(p name398 + (input eat orchid) + (object ^name orchid ^place held) + --> + (remove 1) + (remove 2) + (write (crlf) |Chomp! chomp. I don't think your real family had a taste for orchids.|) + (write (crlf) |It looks like you aren't one of those that knows how to digest orchids.|)) + +(p name399 + (input eat orchid) + (status ^name <x> St |.| John) + (object ^name orchid ^place held) + --> + (remove 1) + (remove 2) + (remove 3) + (write (crlf) |An orchid a day keeps the crazies away!|) + (make command ^string eat_it)) + +(p name400 + (location ^name <x>) + (object ^name orchid ^place <x>) + (input eat orchid) + --> + (make input get orchid)) + +(p name401 + (input say <x>) + --> + (remove 1) + (make input <x>) + (write (crlf) |You can just type| <x> ) + (write (crlf) |and I'll try and understand| <x> |right now.|)) + +(p name402 + (input << scream shout yell >> <x>) + --> + (write (crlf) |'| <x> |!!'|) + (remove 1) + (write (crlf) |I don't think anybody is listening.|)) + +(p name403 + (input hello) + --> + (remove 1) + (write (crlf) |Your greeting is met with silence.|)) + +(p name404 + (input fly) + --> + (remove 1) + (write (crlf) |You flap your arms, but nothing happens.|)) + +(p name405 + (input afihywn) + --> + (remove 1) + (write (crlf) |Hmm, is that Australian?|)) + +(p name1009 + (location ^name bus_stop) + --> + (write (crlf) |We are at an intersection of two streets going n-s and e-w.|) + (write (crlf) |There is a bus stop here.|) + (write (crlf) |To the west a bus is pulling away from the next bus stop.|)) + +(p name1010 + (location ^name bus_stop) + (status ^going <> nil) + (time ^realtime <x> ^btime <y>) + --> + (modify 1 ^name bus_stop) + (modify 2 ^going nil) + (modify 3 ^btime (compute <x> + 16))) + +(p name1011 + (location ^name bus_stop) + (time ^realtime <x> ^btime <x>) + (history ^bus_stopped nil) + --> + (modify 3 ^bus_stopped t)) + +(p name1012 + (location ^name bus_stop) + (history ^bus_stopped t) + --> + (write (crlf) |A bus has stopped in front of us.|)) + +(p name1013 + (input wait) + --> + (write (crlf) |La dee da.|) + (remove 1)) + +(p name1014 + (input wait) + (location ^name bus_stop) + (history ^bus_stopped nil) + --> + (remove 1) + (modify 3 ^bus_stopped t) + (write (crlf) |Yawn!|)) + +(p name1015 + (input << mount board >>) + (location ^name bus_stop) + --> + (remove 1) + (make input enter bus)) + +(p name1016 + (input enter) + (location ^name bus_stop) + (history ^bus_stopped t) + (object ^name tokens ^place held) + --> + (remove 1) + (modify 2 ^name on_bus) + (modify 3 ^bus_stopped nil) + (remove 4) + (make object ^name token ^place held)) + +(p name1017 + (input enter) + (location ^name bus_stop) + (history ^bus_stopped t) + (object ^name token ^place held) + --> + (remove 1) + (modify 2 ^name on_bus) + (modify 3 ^bus_stopped nil) + (remove 4)) + +(p name1018 + (location ^name bus_stop) + (input take ride) + --> + (remove 1) + (make input enter bus)) + +(p name1019 + (location ^name bus_stop) + (history ^bus_stopped t) +-(object ^name tokens) +-(object ^name token) + (status) + (input enter <x>) + --> + (remove 4) + (write (crlf) |You don't have any tokens. You sit on the corner and starve to death.|) + (modify 3 ^quit t)) + +(p name1020 + (location ^name bus_stop) + (history ^bus_stopped t) + (input enter) + (object ^name token ^place bus stop) + --> + (remove 3) + (write (crlf) |The bus doors remain closed.|)) + +(p name1021 + (location ^name bus_stop) + (history ^bus_stopped t) + (input enter) + (object ^name tokens ^place bus stop) +--> + (remove 3) + (write (crlf) |You stumble over some tokens and bang your head on the bus.|)) + +(p name1022 + (location ^name on_bus) + --> + (modify 1 ^name bus) + (make place bus ^visited t) + (write (crlf) |As you find your seat, you notice the bus is empty.|) + (write (crlf) |There isn't even a driver. But before you can change your mind,|) + (write (crlf) |the bus starts up and drives away from the intersection.|) + (write (crlf) |Va Vooooom!|) + (write (crlf) |Looking out the window you see many intersections flash by.|) + (write (crlf) | |) + (write (crlf) |After a while the intersections get farther apart.|) + (write (crlf) |The bus is now in the outskirts of town.|) + (write (crlf) |The bus comes up to an old mansion with a high gate surrounding it and stops.|) + (write (crlf) |A voice comes over the speaker: 'ALL OUT, END OF THE LINE.'|)) + +(p name1023 + (location ^name bus) + (place ^name bus ^visited nil) + --> + (write (crlf) | |) + (write (crlf) |You are in a bus. There isn't a driver and the exit doors are open.|)) + +(p name1024 + (location ^name bus) + (input get off <x>) + --> + (remove 2) + (make input exit)) + +(p name1025 + (location ^name bus) + (input << leave depart disembark >>) + --> + (remove 2) + (make input exit)) + +(p name1026 + (location ^name bus) + (input exit <x>) + --> + (remove 2) + (modify 1 ^name lawn ^side out ^east 5 ^north 2) + (write (crlf) |The bus drives off as you get off.|)) + +(p name1027 + (location ^name bus) + (input get out <x>) + --> + (remove 2) + (make input exit)) + +(p name1028 + (location ^name bus_stop) + (input << chase follow catch >> bus) + (status) + --> + (remove 2) + (write (crlf) |I'm assuming that means GO WEST.|) + (modify 3 ^going w went w)) + +(p name1029 + (location ^name bus_stop) + (time ^realtime 2226) + --> + (write (crlf) |Hint: patience is a virtue.|)) + +(p name1030 + (location ^name bus) + (input hijack bus) + --> + (remove 2) + (write (crlf) |Sorry, this bus doesn't go to Cuba, that's another line.|)) + +(p name1031 + (location ^name bus) + (input <x> driver) + --> + (remove 2) + (write (crlf) |There isn't a driver on this bus.|)) + +(p name1032 + (location ^name bus) + (input drive bus) + --> + (remove 2) + (write (crlf) |I'm sorry but you don't have a chauffeur's license.|)) + +(p name1033 + (location ^name bus) + (input <x> bus) + --> + (remove 2) + (write (crlf) |Give up and get off the bus.|)) + +(p name1034 + (location ^name bus_stop) + (input hail bus) + --> + (remove 2) + (write (crlf) |The bus does not stop for you.|)) + +(p name1035 + (location ^name lawn ^side out ^east {<< 2 3 4 5 6 7 >> <C>} + ^north << 1 2 8 >>) + (status ^going e) + --> + (modify 2 ^going nil) + (modify 1 ^east (compute 1 + <C>))) + +(p name01035 + (location ^name lawn ^side out ^east 1) + (status ^going e) + --> + (modify 2 ^going nil) + (modify 1 ^east 2)) + +(p name1036 + (location ^name lawn ^side out ^east << 1 2 8 >> + ^north {<< 2 3 4 5 6 7 >> <N>}) + (status ^going n) + --> + (modify 2 ^going nil) + (modify 1 ^north (compute 1 + <N>))) + +(p name001036 + (location ^name lawn ^side out ^north 1) + (status ^going n) + --> + (modify 2 ^going nil) + (modify 1 ^north 2)) + +(p name1037 + (location ^name lawn ^side out ^east << 1 2 8 >> + ^north {<< 3 4 5 6 7 8 >> <N>}) + (status ^going s) + --> + (modify 2 ^going nil) + (modify 1 ^north (compute <N> - 1))) + +(p name01037 + (location ^name lawn ^side out ^north 2) + (status ^going s) + --> + (modify 2 ^going nil) + (modify 1 ^north 1)) + +(p name1038 + (location ^name lawn ^side out ^east {> 2 <E>} ^north << 1 2 8 >>) + (status ^going w) + --> + (modify 2 ^going nil) + (modify 1 ^east (compute <E> - 1))) + +(p name01038 + (location ^name lawn ^side out ^east 2) + (status ^going w) + --> + (modify 2 ^going nil) + (modify 1 ^east 1)) + +(p name1039 + (location ^name lawn ^side out ^east 1 ^north <> 1) + (status ^going w) + --> + (modify 2 ^going nil) + (write (crlf) |The woods are too dense to penetrate.|)) + +(p name1041 + (location ^name lawn ^side out ^east 1 ^north 1) + (status ^going w) + --> + (modify 2 ^going nil) + (modify 1 ^name bus_stop)) + +(p name1043 + (location ^name lawn ^side out ^east 8 ^north 1) + (status ^going e) + --> + (modify 2 ^going nil) + (modify 1 ^name bus_stop)) + +(p name1044 + (location ^name lawn ^side out ^east 8 ^north <> 1) + (status ^going e) + --> + (modify 2 ^going nil) + (write (crlf) |You are unable to penetrate into the woods.|)) + +(p name1045 + (location ^name lawn ^side out ^north 1) + (status ^going s) + --> + (modify 2 ^going nil) + (write (crlf) |The forest can not be penetrated.|)) + +(p name1046 + (location ^name lawn ^side out ^north 8) + (status ^going n) + --> + (modify 2 ^going nil) + (write (crlf) |Penetration into the forest is impossible|)) + +(p name1047 + (location ^name lawn ^side out ^east << 3 4 5 6 7 >> ^north 2) + (status ^going n) + --> + (modify 2 ^going nil) + (write (crlf) |The wall prevents passage to the north.|)) + +(p name1049 + (location ^name lawn ^side out ^east << 3 4 5 6 7 >> ^north 8) + (status ^going s) + --> + (modify 2 ^going nil) + (write (crlf) |The wall is in the way.|)) + +(p name1051 + (location ^name lawn ^side out ^east << 3 4 5 6 7 >> ^north 8) + --> + (write (crlf) |You're on the north border of a wall, on the outside.|)) + +(p name1053 + (location ^name lawn ^side out ^east << 3 4 5 6 7 >> ^north 2) + --> + (write (crlf) |To the north is the wall that surrounds CHEZ MOOSE.|) + (write (crlf) |To the south is a road.|)) + +(p name1055 + (location ^name lawn ^side out ^north << 3 4 5 6 7 >> ^east 2) + --> + (write (crlf) |To the west is a thick forest, and to the east is a wall.|)) + +(p name1056 + (location ^name lawn ^side out ^east 8 ^north << 3 4 5 6 7 >>) + --> + (write (crlf) |To the east is a dark forest, and to the west is a high wall.|)) + +(p name1060 + (location ^name lawn ^side out ^east 2 ^north << 3 4 5 6 7 >>) + (status ^going e) + --> + (modify 2 ^going nil) + (write (crlf) |Ahh, there is the big wall in the way.|)) + +(p name1061 + (location ^name lawn ^side out ^east 8 ^north << 3 4 5 6 7 >>) + (status ^going w) + --> + (modify 2 ^going nil) + (write (crlf) |The wall is in the way.|)) + +(p name1074 + (location ^name lawn ^side out ^north 1) + --> + (write (crlf) |You are on the road, to the south is a forest.|)) + +(p name1075 + (location ^name lawn ^side out ^east 1 ^north > 1) + --> + (write (crlf) |You are in a forest.|)) + +(p name1098 + (location ^name lawn ^side out ^east 5 ^north 2) + --> + (write (crlf) |To the north is a gate in a wall.|) + (write (crlf) |Further north a huge mansion looms.|) + (write (crlf) | |) + (write (crlf) |Lights from inside illuminate the surrounding estate.|) + (write (crlf) |The gate is inoperable, and you won't be able to open it.|)) + +(p name1114 + (location ^name lawn ^side out ^east 2 ^north 2) + --> + (write (crlf) |This is the sw corner of the wall.|)) + +(p name1115 + (location ^name lawn ^side out ^east 8 ^north 2) + --> + (write (crlf) |This is the se corner of the wall. You can go n, s, e or w.|)) + +(p name1116 + (location ^name lawn ^side out ^east 8 ^north 8) + --> + (write (crlf) |This is the ne corner of the wall.|)) + +(p name1117 + (location ^name lawn ^side out ^east 2 ^north 8) + --> + (write (crlf) |This is the nw corner of the wall.|)) + +(comment inside) + +(p name1140 + (location ^name lawn ^side in ^east << 2 3 4 6 7 8 >> + ^north { < 8 <N>}) + (status ^going n) + --> + (modify 2 ^going nil) + (modify 1 ^north (compute 1 + <N>) ^general nil)) + +(p name1141 + (location ^name lawn ^side in ^east 5 + ^north { << 2 3 6 7 >> <N>}) + (status ^going n) + --> + (modify 2 ^going nil) + (modify 1 ^north (compute 1 + <N>) ^general nil)) + +(p name1142 + (location ^name lawn ^side in ^east << 2 3 4 6 7 8 >> + ^north { > 2 <N>}) + (status ^going s) + --> + (modify 2 ^going nil) + (modify 1 ^north (compute <N> - 1) ^general nil)) + +(p name1143 + (location ^name lawn ^side in ^east 5 + ^north { << 3 4 7 8 >> <N>}) + (status ^going s) + --> + (modify 2 ^going nil) + (modify 1 ^north (compute <N> - 1) ^general nil)) + +(p name1150 + (location ^name lawn ^side in ^north << 2 3 4 6 7 8 >> + ^east { < 8 <N>}) + (status ^going e) + --> + (modify 2 ^going nil) + (modify 1 ^east (compute 1 + <N>) ^general nil)) + +(p name1151 + (location ^name lawn ^side in ^north 5 + ^east { << 2 3 6 7 >> <N>}) + (status ^going e) + --> + (modify 2 ^going nil) + (modify 1 ^east (compute 1 + <N>) ^general nil)) + +(p name1152 + (location ^name lawn ^side in ^north << 2 3 4 6 7 8 >> + ^east { > 2 <N>}) + (status ^going w) + --> + (modify 2 ^going nil) + (modify 1 ^east (compute <N> - 1) ^general nil)) + +(p name1153 + (location ^name lawn ^side in ^north 5 + ^east { << 3 4 7 8 >> <N>}) + (status ^going w) + --> + (modify 2 ^going nil) + (modify 1 ^east (compute <N> - 1) ^general nil)) + +(p name1048 + (location ^name lawn ^side in ^north 2) + (status ^going s) + --> + (modify 2 ^going nil) + (write (crlf) |The wall won't let you go south.|)) + +(p name1050 + (location ^name lawn ^side in ^north 8) + (status ^going n) + --> + (modify 2 ^going nil) + (write (crlf) |Hey, the wall is north.|)) + +(p name1052 + (location ^name lawn ^side in ^north 8) + --> + (write (crlf) |You're on the inside of north border of a wall.|)) + +(p name1054 + (location ^name lawn ^side in ^north 2) + --> + (write (crlf) |A wall is to the south.|)) + +(p name1057 + (location ^name lawn ^side in ^east 8) + --> + (write (crlf) |To the east is a wall.|)) + +(p name1058 + (location ^name lawn ^side in ^east 2) + --> + (write (crlf) |To the west is a wall.|)) + +(p name1059 + (location ^name lawn ^side in ^east 2) + (status ^going w) + --> + (modify 2 ^going nil) + (write (crlf) |The wall blocks your way.|)) + +(p name1062 + (location ^name lawn ^side in ^east 8) + (status ^going e) + --> + (modify 2 ^going nil) + (write (crlf) |The wall is in the way.|)) + +(p name1063 + (location ^name lawn ^side in ^east 4 ^north 4) + --> + (write (crlf) |You are at the sw corner of the house.|)) + +(p name1064 + (location ^name lawn ^side in ^east 6 ^north 4) + --> + (write (crlf) |You are at the se corner of the house.|)) + +(p name1065 + (location ^name lawn ^side in ^east 4 ^north 5) + --> + (write (crlf) |You are on the west side of the house.|)) + +(p name1066 + (location ^name lawn ^side in ^east 4 ^north 6) + --> + (write (crlf) |This is the north-west corner of the house.|)) + +(p name1067 + (location ^name lawn ^side in ^east 5 ^north 6) + --> + (write (crlf) |This is the north side of the house.|)) + +(p name1068 + (location ^name lawn ^side in ^east 6 ^north 6) + --> + (write (crlf) |This is the north east corner of the mansion.|)) + +(p name1069 + (location ^name lawn ^side in ^east 6 ^north 5) + --> + (write (crlf) |This is the east side of the house.|)) + +(p name1070 + (location ^name lawn ^side in ^east 6 ^north 5) + (status ^going w) + --> + (modify 2 ^going nil) + (write (crlf) |The house is in the way.|)) + +(p name1071 + (location ^name lawn ^side in ^east 4 ^north 5) + (status ^going e) + --> + (modify 2 ^going nil) + (write (crlf) |The house is in the way.|)) + +(p name1072 + (location ^name lawn ^side in ^east 5 ^north 4) + (status ^going n) + --> + (modify 2 ^going nil) + (write (crlf) |The house is in the way.|)) + +(p name1073 + (location ^name lawn ^side in ^east 5 ^north 6) + (status ^going s) + --> + (modify 2 ^going nil) + (write (crlf) |The house is in the way.|)) + +(p name1076 + (location ^name lawn ^side in ^east 3 ^north 3 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1077 + (location ^name lawn ^side in ^east 4 ^north 3 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1078 + (location ^name lawn ^side in ^east 6 ^north 3 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1079 + (location ^name lawn ^side in ^east 7 ^north 3 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1080 + (location ^name lawn ^side in ^east 7 ^north 4 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1081 + (location ^name lawn ^side in ^east 7 ^north 7 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1082 + (location ^name lawn ^side in ^east 6 ^north 7 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1083 + (location ^name lawn ^side in ^east 5 ^north 7 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1084 + (location ^name lawn ^side in ^east 4 ^north 7 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1085 + (location ^name lawn ^side in ^east 3 ^north 6 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1086 + (location ^name lawn ^side in ^east 3 ^north 7) + --> + (write (crlf)|This looks like an old garden, but the land is all dried and hard.|)) + +(p name1087 + (object ^name bathwater ^place lawn ^side in ^east 3 ^north 7) + (object ^name orchid ^state seed) + --> + (modify 2 ^state plant) + (write (crlf) |The ground shakes...|) + (write (crlf) |An orchid sprouts from the ground.|)) + +(p name1088 + (object ^name water ^place lawn ^side in ^east 3 ^north 7) + (object ^name orchid ^place lawn ^side in ^east 3 ^north 7 ^state plant) + (object ^name bathwater ^place lawn ^side in ^east 3 ^north 7) + --> + (remove 2) + (write (crlf) |The orchid shrinks and disappears underground.|)) + +(p name1089 + (object ^name water ^place lawn ^side in ^east 3 ^north 7) + (object ^name orchid ^place lawn ^side in ^east 3 ^north 7 ^state seed) +--> + (remove 2) + (write (crlf) |Nothing happens. That must be strange water.|)) + +(p name1090 + (object ^name seawater ^place lawn ^side in ^east 3 ^north 7) + (object ^name orchid ^place lawn ^side in ^east 3 ^north 7) +--> + (remove 2) + (write (crlf) |I think you killed what ever was planted.|)) + +(p name1091 + (object ^name bathwater ^place <x>) + (object ^name water ^place <x>) +--> + (remove 1) + (remove 2) + (write (crlf) |The two types of water evaporate.|)) + +(p name1092 + (location ^name lawn ^side in ^east 3 ^north 5 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1093 + (location ^name lawn ^side in ^east 3 ^north 4 ^general nil) + --> + (modify 1 ^general lawns)) + +(p name1094 + (location ^general lawns) + --> + (write (crlf) |You're on the lawn of the mansion.|)) + +(p name1095 + (location ^name lawn ^side in ^east 5 ^north 3) + --> + (write (crlf) |You're on the front walk.|)) + +(p name1096 + (location ^name lawn ^side in ^east 5 ^north 2) + --> + (write (crlf) |You're at the front gate, which can't be opened.|)) + +(p name1097 + (location ^name lawn ^side <side> ^east 5 ^north 2) + (input climb) + --> + (remove 2) + (write (crlf) |Nice try, but the upper part of the gate is electrified!|) + (write (crlf) |I suggest you try somewhere else.|)) + +(p name1105 + (location ^name lawn ^side in ^east 7 ^north 5) + --> + (write (crlf) |You are on the drive way.|) + (write (crlf) |The drive has a gate in the wall to the east.|)) + +(p name1106 + (location ^name lawn ^side in ^east 7 ^north 6) + --> + (write (crlf) |You are on a parking space.|)) + +(p name1118 + (location ^name lawn) + (input << scale climb >>) + --> + (remove 2) + (write (crlf) |The wall is too slick to climb up. You can't get a grip.|)) + +(p name1119 + (location ^name lawn) + (input << burrow tunnel dig >>) + --> + (remove 2) + (write (crlf) |The ground is too hard to dig here.|)) + +(p name1120 + (location ^name lawn) + (object ^name <x> ^place held) + (input throw <x> at wall) + --> + (remove 3) + (write (crlf) |The| <x> |bounces off the wall.|) + (make input drop <x>)) + +(p name1121 + (input jump wall) + (location ^name lawn) + --> + (remove 1) + (write (crlf) |You aren't the HULK or Dwight Stones.|)) + +(p name1122 + (input jump wall) + (location ^name lawn) + (status ^name Dwight Stones) +--> + (remove 1) + (write (crlf) |You approach the wall. Up, up you go.|) + (write (crlf) |SPLAT!! You hit the wall right at 8". That would|) + (write (crlf) |be a new world's record. Too bad the wall is ten feet tall.|)) + +(p name1123 + (input jump wall) + (location ^name lawn) + (status ^name the Hulk) + --> + (remove 1) + (write (crlf) |Ha! You aren't the Hulk, you're just a little green|) + (write (crlf) |from the bus ride.|)) + +(p name1124 + (input jump over wall) + (location ^name lawn) + --> + (remove 1) + (write (crlf) |You watched Superman too many times!|)) + +(p name1125 + (location ^name lawn) + (input throw <y> over <Z>) + --> + (remove 2) + (write (crlf) |The wall is too high for you to throw anything over it.|)) + +(p name1126 + (input let me in) + --> + (remove 1) + (write (crlf) |I'm afraid you aren't getting anyone's attention.|)) + +(p name1127 + (input open gate) + --> + (remove 1) + (write (crlf) |The gate can't be opened by you.|)) + +(p name1128 + (status ^notreasure t) + (object ^name <x> ^place ) + --> + (remove 2)) + +(p name1129 + (location ^name lawn ^side in ^east 5 ^north 6) + --> + (write (crlf) |There is ivy on the walls of the house.|)) +(p name389 + (time ^oil_status oil ^oil_time <x> ^realtime <x>) + --> + (modify 1 ^oil_status enter ^oil_time (compute <x> + 10))) + +(p name390 + (time ^oil_status enter ^oil_time <x> ^realtime <x>) + --> + (make object ^name truck ^place lawn ^side in ^east 7 ^north 5) + (modify 1 ^oil_status walk ^oil_time (compute <x> + 10))) + +(p name391 + (time ^oil_status walk ^oil_time <x> ^realtime <x>) + (history ^grave_status undug) + --> + (modify 1 ^oil_status walk ^oil_time (compute <x> + 4)) + (modify 2 ^grave_status dug)) + +(p name392 + (time ^oil_status walk ^oil_time <x> ^realtime <x>) + (history ^grave_status dug) + --> + (modify 1 ^oil_status walk ^oil_time (compute <x> + 4)) + (modify 2 ^grave_status deep)) + +(p name393 + (time ^oil_status walk ^oil_time <x> ^realtime <x>) + (history ^grave_status deep ^grave_status2 oil) + --> + (modify 2 ^grave_status2 nil) + (modify 1 ^oil_status fixit ^oil_time (compute <x> + 8))) + +(p name394 + (time ^oil_status fixit ^oil_time <x> ^realtime <x>) + --> + (make fixed) + (modify 1 ^oil_status return ^oil_time (compute <x> + 10))) + +(p name395 + (time ^oil_status return ^oil_time <x> ^realtime <x>) + (object ^name truck ^place <y>) + --> + (modify 1 ^oil_status done) + (remove 2)) + +(p name500 + (location ^name lawn ^side in ^east 8 ^north 8) + (history ^grave_status undug) +--> + (write (crlf) |There is a fresh grave here.|)) + +(p name501 + (location ^name lawn ^side in ^east 8 ^north 8) + (history ^grave_status undug) + (input dig) + --> + (remove 3) + (modify 2 ^grave_status dug) + (write (crlf) |Luckily, the dirt is soft.|)) + +(p name502 + (location ^name lawn ^side in ^east 8 ^north 8) + (history ^grave_status dug) +--> + (write (crlf) |There is a open grave.|)) + +(p name503 + (location ^name lawn ^side in ^east 8 ^north 8) + (history ^grave_status dug) + (input dig) + --> + (remove 3) + (modify 2 ^grave_status deep)) + +(p name504 + (location ^name lawn ^side in ^east 8 ^north 8) + (history ^grave_status deep) +--> + (write (crlf) |There is a large pipe that goes through the grave.|) + (write (crlf) |There is a lever on the pipe labelled 'Emergency Release.'|)) + +(p name505 + (location ^name lawn ^side in ^east 8 ^north 8) + (input <x> dirt <y>) + --> + (remove 2) + (write (crlf) |Hmmm.. I didn't understand that. I can only dig holes and fill in holes.|)) + +(p name506 + (location ^name lawn ^side in ^east 8 ^north 8) + (input get dirt) + --> + (remove 2) + (write (crlf) |Sorry, that won't wash. I can only dig holes and fill in holes.|) + (write (crlf) |You can't get the dirt.|)) + +(p name507 + (location ^name lawn ^side in ^east 8 ^north 8) + (input pull lever) + (history ^grave_status deep ^grave_status2 <> oil) + (time ^realtime <x>) +-(fixed) + --> + (remove 2) + (write (crlf) |Ummph!|) + (modify 3 ^grave_status2 oil) + (modify 4 ^oil_time (compute <x> + 30))) + +(p name508 + (location ^name lawn ^side in ^east 8 ^north 8) + (history ^grave_status2 oil) +--> + (write (crlf) |There is oil seeping out of the pipe.|)) + +(p name509 + (input << throw get push turn close >> lever) + --> + (remove 1) + (make input pull lever)) + +(p name510 + (input <x> lever) + --> + (remove 1) + (write (crlf) |I don't understand the word| <x> |as a verb for lever.|)) + +(p name511 + (history ^grave_status2 oil) + (input pull lever) + --> + (remove 2) + (write (crlf) |The lever won't close, a special tool is needed!|) + (write (crlf) |The oil continues to seep out.|)) + +(p name512 + (location ^name lawn ^side in ^east 8 ^north 8) + (input <x> oil) + --> + (remove 2) + (write (crlf) |The oil is too slippery to do anything with it.|)) + +(p name513 + (location ^name lawn ^side in ^east 8 ^north 8) + (input refill) + (walk <x>) + (history ^grave_status <y>) + --> + (remove 2) + (write (crlf) |You are unable to affect the driver's digging.|)) + +(p name514 + (location ^name lawn ^side in ^east 8 ^north 8) + (input refill) + (fixit <x>) + (history ^grave_status <y>) + --> + (remove 2) + (write (crlf) |You are unable to affect the driver's work.|)) + +(p name515 + (location ^name lawn ^side in ^east 8 ^north 8) + (input refill) + (history ^grave_status2 oil ^grave_status deep) + --> + (remove 2) + (modify 3 ^grave_status dug) + (write (crlf) |The oil still seeps out.|)) + +(p name516 + (location ^name lawn ^side in ^east 8 ^north 8) + (history ^grave_status deep) + (input refill) + --> + (remove 3) + (modify 2 ^grave_status dug)) + +(p name517 + (location ^name lawn ^side in ^east 8 ^north 8) + (history ^grave_status dug) + (input refill) + --> + (remove 3) + (modify 2 ^grave_status undug)) + +(p name518 + (input oil) + (location ^name lawn ^side in ^east 8 ^north 8) +--> + (remove 1) + (write (crlf) |The oil is too slippery to use.|)) + +(p name519 + (input fill in) + --> + (remove 1) + (make input refill)) + +(p name520 + (input fillin) + --> + (remove 1) + (make input refill)) + +(p name521 + (input cover) + --> + (remove 1) + (make input refill)) + +(p name522 + (input << scoop shovel >>) + --> + (remove 1) + (make input dig)) + +(p name523 + (input dig) + (location ^name lawn ^side in ^east 8 ^north 8) +--> + (remove 1) + (write (crlf) |The ground is too hard to dig anymore.|)) + +(p name524 + (input refill) + (location ^name lawn ^side in ^east 8 ^north 8) +--> + (remove 1) + (write (crlf) |The grave is filled.|)) + +(p name525 + (history ^grave_status dug) +-(object ^name bone) +--> + (make object ^name bone ^place lawn ^side in ^east 8 ^north 8 ^treasure t)) + +(p name526 + (fixed) + (location ^name lawn ^side in ^east 8 ^north 8) + --> + (write (crlf) |The oil is not seeping out, the lever has been fixed but can not be pulled.|)) + +(p name527 + (fixed) + (location ^name lawn ^side in ^east 8 ^north 8) + (input pull) + --> + (remove 3) + (write (crlf) |The lever won't budge.|)) + + +(p name530 + (location ^name lawn ^side in ^east 8 ^north 5) + (enter) + --> + (write (crlf) |You see a truck outside at the gate.|)) + +(p name531 + (location ^name lawn ^side in ^east > 6 ^north 5) + (enter <x>) + (time ^realtime <x>) + (input <z>) + --> + (write (crlf) |The gates open and the truck enters. The gate closes before you can escape.|) + (write (crlf) |The truck says 'Oil line fixit' on the side.|) + (write (crlf) |The truck pulls in and parks on the drive.|) + (write (crlf) |The driver gets out and heads north east.|)) + +(p name532 + (enter <x>) + (time ^realtime <x>) +-(location ^name lawn ^side in ^east > 6 ^north 5) + (input <z>) + --> + (write (crlf) |You hear a truck pull into the driveway and stop.|)) + +(p name533 + (walk <x>) + (location ^name lawn ^side in ^east 8 ^north 8) + --> + (write (crlf) |The driver is digging to get a better angle on the pipe.|)) + +(p name534 + (fixit <x>) + (location ^name lawn ^side in ^east 8 ^north 8) + --> + (write (crlf) |The driver is fixing the pipe.|)) + +(p name535 + (fixit <x>) + (time ^realtime <x>) + (location ^name lawn ^side in ^east 8 ^north 8) + (input <z>) + --> + (write (crlf) |The driver is finished with the work, and heads back to the truck.|)) + +(p name536 + (return <x>) + (time ^realtime <x>) + (input <z>) + (location ^name lawn ^side in ^east > 6 ^north 5) + --> + (write (crlf) |The man gets in the truck and backs out as the gate opens.|) + (write (crlf) |You are unable to escape as it leaves.|)) + +(p name537 + (input <x> driver <y>) + --> + (remove 1) + (write (crlf) |You are unable to contact or make contact with the driver.|) + (write (crlf) |It is as if he doesn't know you are there.|)) + +(p name538 + (input get truck) + --> + (remove 1) + (write (crlf) |The truck is a little heavy to get.|)) + +(p name539 + (location ^name lawn ^side in ^east 7 ^north 5) + (portal ^name truck ^place lawn ^side in ^east 7 ^north 5) + --> + (write (crlf) |There is a panel truck here.|)) + +(p name540 + (location ^name lawn ^side in ^east 7 ^north 5) + (portal ^name truck ^place lawn ^side in ^east 7 ^north 5) + (input mount truck) + --> + (remove 3) + (write (crlf) |The truck is too tall to climb up on.|)) + +(p name541 + (location ^name lawn ^side in ^east 7 ^north 5) + (object ^name truck ^place lawn ^side in ^east 7 ^north 5) + (input open <y>) + --> + (remove 3) + (write (crlf) |The front doors are locked, but you were able to open the back.|) + (modify 2 ^door open)) + +(p name542 + (portal ^name truck ^door closed) + (object ^name truck ^side in ^east 7 ^north 5) + (location ^name lawn ^side in ^east 7 ^north 5) + (input open <y>) + --> + (write (crlf) |The back doors are now open.|) + (modify 1 ^door open) + (remove 4)) + +(p name543 + (location ^name lawn ^side in ^east 7 ^north 5) + (object ^name truck ^place lawn ^side in ^east 7 ^north 5) + (input << mount enter >> <y>) + --> + (remove 3) + (write (crlf) |None of the doors are open.|)) + +(p name544 + (location ^place lawn ^side in ^east 7 ^north 5) + (object ^name truck ^place lawn ^side in ^east 7 ^north 5) + (portal ^name truck ^door open) + (input close <y>) +--> + (modify 3 ^door close) + (remove 4) + (write (crlf) |Ok.|)) + +(p name545 + (location ^name lawn ^side in ^east 7 ^north 5) + (object ^name truck ^place lawn ^side in ^east 7 ^north 5) + (portal ^name truck ^door open) + (input << mount enter >> <h>) +--> + (remove 4) + (modify 1 ^place intruck) + (write (crlf) |You are in the back of the truck.|)) + +(p name546 + (location ^name intruck) + (input look) + --> + (remove 2) + (write (crlf) |You are inside the panel truck. It is empty.|)) + +(p name547 + (object ^name truck ^place lawn ^side in ^east 7 ^north 5) + (portal ^name truck ^door open) + (location ^name intruck) + (return <y>) + (time ^realtime <y>) + (input <z>) + --> + (write (crlf) |As the truck starts up, it accelerates so fast that you fall out the back.|) + (remove 6) + (modify 3 ^place lawn ^side in ^east 7 ^north 5)) + +(p name548 + (object ^name truck ^place lawn ^side in ^east 7 ^north 5) + (portal ^name truck ^door closed) + (location ^name intruck) + (return <y>) + (time ^realtime <y>) + (input <z>) + (status) + --> + (remove 6) + (write (crlf) |VaVoom! The truck has started up.|) + (write (crlf) |Bump bump! You feel yourself being driven out of the yard.|) + (modify 7 ^going out)) + +(p name549 + (location ^name lawn ^side in ^east 7 ^north 5) + (object ^name truck ^place lawn ^side in ^east 7 ^north 5) + (portal ^name truck ^door open) + (input << mount enter >> <R>) + (object ^name <y> ^place held) + --> + (remove 4) + (write (crlf) |The| <y> |won't fit through the door!|)) + +(p name550 + (status ^going out) + --> + (modify 1 ^going nil) + (write (crlf) |As you drive by the gate you hear from the speaker:|) + (write (crlf) |'Good job son!'|) + (write (crlf) ||) + (write (crlf) |The truck drives on for a while then stops.|) + (write (crlf) |Your open the truck door and find that you are outside the walls.|) + (write (crlf) |You've escaped!|) + (write (crlf) ||) + (write (crlf) |In the distance you here the trumpeting of a bull moose.|) + (write (crlf) ||) + (write (crlf) |James Watt is here with a check for $10,000,000 to buy the land|) + (write (crlf) |for the Department of the Interior.|) + (write (crlf) |He assures you that the government will not sell the land, but admits|) + (write (crlf) |that he may allow some leasing of mineral rights. You have the option|) + (write (crlf) |of selling it and making big bucks, or you can donate, with the|) + (write (crlf) |restriction that it be perserved in its current state.|) + + (write (crlf) |What is your choice? Sell, or donate?|) + (make selldonate (accept))) + +(p name551 + (selldonate sell) + (status ^score <x>) + --> + (remove 1) + (write (crlf) |Hmm. I don't think your father would have approved.|) + (write (crlf) |Oh my god! Out of the forest a moose comes charging at you.|) + (write (crlf) |He is coming right at you. You can't escape. |) + (write (crlf) |ARGHH! He gored you, but missed James Watt.|) + (write (crlf) |You're dead, what a bummer after what you have been through.|) + (make input stop) + (modify 2 ^score (compute <x> - 20))) + +(p name552 + (selldonate) + --> + (remove 1) + (write (crlf) |Make up your mind, Sell or donate.|) + (make selldonate (accept))) + +(p name553 + (selldonate donate) + (status ^score <x>) + --> + (remove 1) + (write (crlf) |James Watt accuses you of being a reactionary idiot.|) + (write (crlf) |He stomps off, mumbling, 'Those strip miners are going|) + (write (crlf) |to be real disappointed', and walks right through a pile of moose turds.|) + (write (crlf) |I think you made the right decision.|) + (make gone) + (modify 2 ^score (compute <x> + 20))) + +(p name554 + (gone) + --> + (make input stop)) + +(p name555 + (gone) + (status ^score <x>) + (object ^name cube ^place lawn) + --> + (modify 2 ^score (compute <x> - 50)) + (make input stop) + (write (crlf) |The police bust into the yard of the house to collect|) + (write (crlf) |your treasure for you.|) + (write (crlf) |Unfortunately they find the sugar cube with the LSd in it.|) + (write (crlf) |You are arrested and thrown in jail for 50 years!!!|) + (write (crlf) |What a loser!|)) + +(p name556 + (gone) + (status ^score <x>) + (object ^name marijuana ^place lawn) +--> + (modify 2 ^score (compute <x> - 20)) + (make input stop) + (write (crlf) |The police bust into the yard of the house to collect your treasure for you.|) + (write (crlf) |They find the marijuana! Luckily you are in the state of confusion|) + (write (crlf) |and you get a $5 fine, but lose the $300 worth of pot.|) + (write (crlf) |Oh well, maybe next time you'll enjoy it first.|)) + +(p name557 + (location ^name intruck) + (input get out) + (portal ^name truck ^door open) + --> + (remove 2) + (modify 1 ^name lawn ^side in ^east 7 ^north 5)) + + +(p name1130 + (location ^name lawn ^side in ^east 5 ^north 6) + (input get ivy) + --> + (remove 2) + (write (crlf) |The ivy is stuck to the wall.|)) + + +(p name1131 + (input hi) + (location ^name lawn ^side out ^east 8 ^north 5) +--> + (remove 1) + (write (crlf) |The gate opens. You rush in and then it closes behind you.|) + (write (crlf) |Out of the speaker you hear, 'Now you are in, but will you ever get out?'|) + (modify 2 ^side in)) + +(p name1132 + (location ^name lawn ^side in ^east 8 ^north 5) + --> + (write (crlf) |You are on the driveway. The gate to the outside|) + (write (crlf) |is to the east, but is locked electronically.|)) + +(p name1133 + (location ^name lawn ^side in ^east 8 ^north 5) + (status ^going e) + --> + (modify 2 ^going nil) + (write (crlf) |The gate is locked, and you can't open it.|)) + +(p name1134 + (location ^name lawn ^side out ^east 8 ^north 5) + --> + (write (crlf) |There is a gate in the wall that spans the|) + (write (crlf) |driveway that leads into the inner grounds of the mansion.|) + (write (crlf) |By the left hand side of the gate is a 'Jack-in-the-box'|) + (write (crlf) | speaker with a button.|)) + +(p name1200 + (input << climb scale >> ) + (location ^name lawn ^side in ^east 5 ^north 6) + --> + (remove 1) + (modify 2 ^name balcony ^side nil ^east nil ^north nil) + (write (crlf) |The ivy allows you to get a grip. You climb up the wall.|) + (write (crlf) |The ivy starts to thin out and you haven't found anywhere to stop.|) + (write (crlf) |To the right you spy a balcony. Using your great skill as a|) + (write (crlf) |world class haunted house climber, you jump to the balcony.|)) + +(p name01200 + (status ^going u) + (location ^name lawn ^side in ^east 5 ^north 6) + --> + (modify 1 ^going nil) + (modify 2 ^name balcony ^side nil ^east nil ^north nil) + (write (crlf) |The ivy allows you to get a grip. You climb up the wall.|) + (write (crlf) |The ivy starts to thin out and you haven't found anywhere to stop.|) + (write (crlf) |To the right you spy a balcony. Using your great skill as a|) + (write (crlf) |world class haunted house climber, you jump to the balcony.|)) + +(p name1201 + (location ^name balcony) + (place ^name balcony ^visited nil) + --> + (write (crlf) |You are on the balcony. The doors to the inside|) + (write (crlf) |are missing leaving a large doorway to the inside.|)) + +(p name1202 + (location ^name balcony) + (status ^going u) + --> + (modify 2 ^going nil) + (write (crlf) |You can't climb any higher.|)) + +(p name1203 + (location ^name balcony) + (input climb up) + (status) + --> + (remove 2) + (modify 3 ^going u ^went u)) + +(p name1204 + (location ^name balcony) + (input climb nil) + --> + (remove 2) + (write (crlf) |Climb up or climb down?|)) + +(p name1205 + (input climb down) + (location ^name balcony) + (status) + --> + (remove 1) + (write (crlf) |I warned you that the ivy gave out up here!|) + (write (crlf) |When you tried to leap over to get a grip, you missed!!|) + (write (crlf) |Down you go|) + (write (crlf) | o|) + (write (crlf) | o|) + (write (crlf) | o|) + (write (crlf) | o.|) + (write (crlf) |Your foot gets caught in some ivy near the bottom and you land|) + (write (crlf) |on your head. |) + (modify 3 ^die t)) + +(p name1206 + (location ^name balcony) + (status ^going d) + --> + (modify 2 ^going nil) + (write (crlf) |Is that climb down or jump?|)) + +(p name1207 + (location ^name balcony) + (input jump) + (status) + --> + (write (crlf) |Paratrooper training comes in helpful sometimes.|) + (write (crlf) |Unfortunately you never had it. You break your neck when you hit.|) + (remove 2) + (modify 3 ^die t)) + +(p name1208 + (location ^name balcony) + (input jump) + (object ^name mattress ^place held) + (status) + --> + (modify 4 ^die t) + (write (crlf) |You flip over in mid-air and land on your back! 'CRUNCH'|) + (remove 2)) + +(p name1209 + (location ^name balcony) + (input jump) + (object ^name mattress ^place lawn ^side in ^east 5 ^north 6) + --> + (remove 2) + (modify 1 ^name lawn ^side in ^east 5 ^north 6) + (write (crlf) |Luckily you land on the mattress.|)) + +(p name1210 + (input drop mattress) + (location ^name balcony) + (object ^name mattress ^place held) + --> + (remove 1) + (modify 3 ^place lawn ^side in ^east 5 ^north 6) + (write (crlf) |The mattress floats to the ground.|)) + +(p name1211 + (input throw mattress) + (location ^name balcony) + --> + (remove 1) + (make input drop mattress)) + +(p name1212 + (input enter) + (location ^name balcony) + (status) + --> + (modify 3 ^going s ^went s) + (remove 1)) + +(p name1213 + (location ^name balcony) + (place ^name balcony) + (status ^going s) + --> + (modify 1 ^name bedroom) + (modify 2 ^name balcony ^visited t) + (modify 3 ^going nil)) + +(p name1214 + (location ^name bedroom) + (place ^name bedroom ^visited nil) + --> + (write (crlf) |You are in what looks like the master bedroom of the mansion.|) + (write (crlf) |A large doorway opens to the balcony to the north.|) + (write (crlf) |To the east is a opening to the bathroom.|) + (write (crlf) |The main doorway to the rest of the house is boarded up and impassable.|)) + +(p name1215 + (input enter) + (location ^name bedroom) + --> + (remove 1) + (make input e)) + +(p name1216 + (location ^name bedroom) + (make input exit) + --> + (remove 2) + (make input n)) + +(p name1217 + (location ^name bedroom) + (object ^name mattress ^place held) + (status ^going e) + --> + (modify 3 ^going nil) + (write (crlf) |The mattress won't fit through the door.|)) + +(p name1218 + (location ^name bedroom) + (object ^name mattress ^place held) + (status ^going n) + --> + (write (crlf) |The mattress just clears the door.|)) + +(p name1219 + (location ^name bedroom) + (place ^name bedroom) + (status ^going n) + --> + (modify 3 ^going nil) + (modify 2 ^name bedroom ^visited t) + (modify 1 ^name balcony)) + +(p name1220 + (location ^name bedroom) + (status ^going e) + (place ^name bedroom) + --> + (modify 2 ^going nil) + (modify 3 ^name bedroom ^visited t) + (modify 1 ^name bathroom)) + +(p name1221 + (location ^name bedroom) + (status ^sound on) + --> + (write (crlf) |Some noise can be heard through the boarded up door.|)) + +(p name1222 + (location ^name bedroom) + (object ^name mattress ^place bedroom) + --> + (write (crlf) |There is a king-size bed in the middle of the room.|)) + +(p name1223 + (location ^name bedroom) +-(object ^name mattress ^place bedroom) + --> + (write (crlf) |There is the frame and springs of a king-size bed in the room.|)) + +(p name1224 + (location ^name bedroom) + (input get bed) + --> + (remove 2) + (write (crlf) |All you can get is the mattress, the rest is too heavy.|) + (make input get mattress)) + +(p name1225 + (location ^name <x>) + (object ^name mattress ^place <x>) + (input cut mattress) + --> + (remove 3) + (remove 2) + (write (crlf) |The mattress is poorly made and you rip it to shreds.|) + (write (crlf) |In fact it is in a million pieces that float away.|)) + +(p name1226 + (input cut mattress) + (object ^name mattress ^place held) + --> + (remove 1) + (remove 2) + (write (crlf) |The mattress falls to pieces in your hands and they all float away.|)) + +(p name1227 + (input << chop rip tear >>) + --> + (remove 1) + (make input cut)) + +(p name1228 + (location ^name bedroom) + (input look under bed) + --> + (remove 2) + (write (crlf) |'Ahhh Chooo!' There is dust under the bed.|)) + +(p name1229 + (location ^name bedroom) + (input <x> under bed) + --> + (remove 2) + (write (crlf) |The bed is too low to go under.|)) + +(p name1230 + (input mount bed) + (location ^name bedroom) + --> + (remove 1) + (modify 2 ^ontop bed) + (write (crlf) |You are on the bed.|)) + +(p name1231 + (location ^name bedroom ^ontop bed) + (object ^name mattress ^place bedroom) + (input jump) +-(object ^name mirror ^state broke) + --> + (remove 3) + (write (crlf) |You bounce up and hit the mirror. It shatters into many small pieces.|) + (make object ^name mirror ^state broke)) + +(p name1232 + (input bounce) + --> + (remove 1) + (make input jump)) + +(p name1233 + (location ^name bedroom ^ontop bed) + (input jump) + --> + (remove 2) + (write (crlf) |Without the mattress on you don't get any cheap thrills.|)) + +(p name1234 + (location ^name bedroom ^ontop <> nil) + (input get mirror) + --> + (remove 2) + (write (crlf) |The mirror is still out of reach.|)) + +(p name1235 + (location ^name bedroom) + (input get mirror) + --> + (remove 2) + (write (crlf) |The mirror is much too high to reach.|)) + +(p name1236 + (location ^name bedroom) +-(object ^name mirror ^state broke) + --> + (write (crlf) |There is a mirror on the ceiling above the bed.|)) + +(p name1237 + (location ^name bedroom) + (object ^name mirror ^state broke) + (input get mirror) + (status ^cut nil) + --> + (remove 3) + (modify 4 ^cut t) + (write (crlf) |The glass is too sharp to carry, you cut yourself. 'Ouch!'|)) + +(p name1238 + (location ^name bedroom ^ontop bed) + (object ^name mirror ^state broke) + (input get mirror <x>) + (status) + --> + (remove 3) + (modify 4 ^cut t) + (write (crlf) |The glass cuts you when you try to pick it up.|)) + +(p name1239 + (location ^name bedroom) + (object ^name mirror ^state broke) + (input get glass) + (status) + --> + (remove 3) + (modify 4 ^cut t) + (write (crlf) |'Ouch!' The glass cuts you, you can't carry it.|)) + +(p name1240 + (location ^name bedroom) + (object ^name mirror ^state broke) + --> + (write (crlf) |There is glass from a broken mirror on the floor.|)) + +(p name1241 + (input sleep) + (location ^name bedroom ^ontop bed) + --> + (write (crlf) |Snooze... + . + . + . + . + . + ... snort. Ah that was refreshing, but useless, you're still ugly.|) + (remove 1)) + +(p name1242 + (input get << on in >> bed) + (location ^name bedroom) + --> + (remove 1) + (make input mount bed)) + +(p name1243 + (location ^name bedroom) + (input sit on bed) + --> + (remove 2) + (make input mount bed)) + +(p name1244 + (x 10) + (input sleep) + --> + (remove 2) + (write (crlf) |Let's wait until we are on a bed.|)) + +(p name1245 + (location ^name {<> bedroom <x>}) + (object ^name mattress ^place <x>) + --> + (write (crlf) |There is a king-size mattress here.|)) + +(p name1246 + (location ^name bathroom) + (place ^name bathroom ^visited nil) + --> + (write (crlf) |You are in the master bathroom.|) + (write (crlf) |The exciting features around are the bathtub and the toilet.|)) + +(p name1247 + (location ^name bathroom) + (status ^going w) + (place ^name bathroom) + --> + (modify 1 ^name bedroom) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name1248 + (location ^name bathroom) + (input urinate) + --> + (remove 2) + (write (crlf) |That was a relief!|)) + +(p name1249 + (location ^name bathroom) + (input urinate) + (status ^likes prince) + --> + (modify 1 ^siton toilet)) + +(p name1250 + (input urinate into bottle) + --> + (remove 1) + (write (crlf) |The adventure has frighten you so much that your|) + (write (crlf) |urethra won't relax|) + (write (crlf) |and you are unable to even expel a drop.|)) + +(p name1251 + (input get urine) + --> + (remove 1) + (make input urinate into bottle)) + +(p name1252 + (input urinate in bottle) + --> + (remove 1) + (make input urinate into bottle)) + +(p name1253 + (input shit) + (location ^name bathroom) + --> + (remove 1) + (modify 2 ^siton toilet) + (write (crlf) |Too bad there isn't any tissue!|)) + +(p name1254 + (input piss) + --> + (remove 1) + (make input urinate)) + +(p name1255 + (input take a leak) + --> + (remove 1) + (make input urinate)) + +(p name1256 + (input take a crap) + (location ^name bathroom) + --> + (remove 1) + (make input shit)) + +(p name1257 + (input mount toilet) + (location ^name bathroom) + --> + (remove 1) + (modify 2 ^siton toilet) + (write (crlf) |Sitting on a toilet is lots of fun!|)) + +(p name1258 + (input sit on toilet) + (location ^name bathroom) + --> + (remove 1) + (modify 2 ^siton toilet) + (write (crlf) |Duly sat.|)) + +(p name1259 + (location ^name bathroom) + (input flush) + (status) + --> + (remove 2) + (modify 3 ^die t) + (write (crlf) |When you flush the toilet it spins around, knocking you off your feet!|) + (write (crlf) |You crack your head on the bathtub and die!!|)) + +(p name1260 + (location ^name bathroom ^siton <> nil) + (status ^going w) + --> + (modify 1 ^siton nil)) + +(p name1261 + (input flush) + (location ^name bathroom ^siton toilet) + (place ^name bathroom) + --> + (remove 1) + (modify 2 ^name backroom) + (modify 3 ^visited t)) + +(p name1262 + (location ^name bathroom) + (input get toilet) + --> + (remove 2) + (write (crlf) |Give me a break! The toilet stays here!|)) + +(p name1263 + (location ^name bathroom) + (input get bathtub) + --> + (write (crlf) |The bathtub doesn't move.|) + (remove 2)) + +(p name1264 + (location ^name bathroom) + (input << enter mount >> bathtub) + --> + (modify 1 ^siton bathtub) + (remove 2) + (write (crlf) |Ok.|)) + +(p name1265 + (location ^name bathroom) + (input sit in bathtub) + --> + (modify 1 ^siton bathtub) + (remove 2) + (write (crlf) |Ok.|)) + +(p name1266 + (location ^name bathroom) + (input turn on water) + (place ^name bathroom) + --> + (remove 2) + (modify 3 ^state water_running)) + +(p name1267 + (location ^name bathroom) + (place ^name bathroom ^state water_running) + --> + (write (crlf) |The water is on in the bathtub.|)) + +(p name1268 + (location ^name bathroom) + (place ^name bathroom ^state <> water_running) + (input turn off water) + --> + (remove 3) + (write (crlf) |The water is already off.|)) + +(p name1269 + (location ^name bathroom) + (place ^name bathroom ^state water_running) + (input turn off water) + --> + (modify 2 ^state nil) + (remove 3) + (write (crlf) |The water is turned off.|) + (write (crlf) |All the water drains out.|)) + +(p name1270 + (location ^name bathroom) + (input turn on shower) + --> + (remove 2) + (write (crlf) |There isn't a shower head, just a bathtub.|)) + +(p name1271 + (location ^name bathroom) + (input take shower) + --> + (remove 2) + (write (crlf) |I thought I said there was only a bathtub!|)) + +(p name1272 + (location ^name bathroom) + (input take bath) + --> + (remove 2) + (make command ^string wash)) + +(p name1273 + (location ^name bathroom) + (input wash) + --> + (remove 2) + (make command ^string wash)) + +(p name1274 + (location ^name bathroom) + (command ^string wash) + (place ^name bathroom ^state <> water_running) + --> + (write (crlf) |Well, I must turn on the water.|) + (modify 3 ^state water_running)) + +(p name1275 + (location ^name bathroom ^siton <> bathtub) + (command ^string wash) + --> + (write (crlf) |Let's get in the bathtub.|) + (modify 1 ^siton bathtub)) + +(p name1276 + (location ^name bathroom) + (command ^string wash) + (object ^name soap ^place bathroom) + --> + (write (crlf) |Hmmm... now where was that soap.|) + (make input get soap)) + +(p name1277 + (location ^name bathroom ^siton bathtub) + (command ^string wash) + (object ^name soap ^place held) + (place ^name bathroom ^state water_running) + --> + (remove 2) + (remove 3) + (write (crlf) |Luckily we don't worry about clothes in this adventure!|) + (write (crlf) |The water is nice and warm. Too bad I don't have a rubber duckie!|) + (write (crlf) |Well let's use the soap to get clean.|) + (write (crlf) |There is so much dirt here it takes alot of soap.|) + (write (crlf) |As the soap wears away, we are left with a GEM!!.|) + (make object ^name gem ^place held ^treasure t)) + +(p name1278 + (x 10) + (command ^string wash) + --> + (remove 1) + (write (crlf) |Ahh, can't wash without any soap and water.|)) + +(p name1279 + (location ^siton bathtub) + (object ^name soap ^place held) + (place ^name bathroom ^state water_running) + --> + (write (crlf) |As long as we're here, we might as well wash.|) + (make command ^string wash)) + +(p name1280 + (location ^name bathroom) + (object ^name soap ^place held) + (input drop soap in << bathtub water >>) + (place ^name bathroom ^state water_running) + --> + (remove 2) + (remove 3) + (write (crlf) |The soap dissolves and a gem remains!|) + (make object ^name gem ^place bathroom ^treasure t)) + +(p name1281 + (location ^siton bathtub) + (object ^name <x> ^wears t) + --> + (remove 1) + (write (crlf) |If we're getting in the bathtub I'm going to take off the| + <x> |.|) + (make input take off <x>)) + +(p name1282 + (location ^name bathroom) + (input lather) + --> + (remove 2) + (make input wash)) + +(p name1283 + (location ^name bathroom) + (input drop soap in water) + --> + (remove 2) + (make input wash)) + +(p name1284 + (location ^name bathroom) + (input drop soap in bathtub) + --> + (remove 2) + (make input wash) + (write (crlf) |Let's jump in after it and take a bath.|)) + +(p name1285 + (location ^name bathroom) + (input drink water) + --> + (remove 2) + (write (crlf) |Gross! I'm not that thirsty!|)) + +(p name1286 + (input urinate <x>) + (object ^name <x> ^wears <> nil) + --> + (remove 1) + (make input take off <x>) + (write (crlf) |Well, I think it is best to undress a little first.|)) + +(p name1287 + (location ^name bathroom) + (input shit) + (object ^name <x> ^wears <> nil) + --> + (remove 2) + (make input take off <x>) + (write (crlf) |I'll take off the suit first.|)) + +(p name1288 + (input pee) + --> + (remove 1) + (make input urinate)) + +(p name1289 + (location ^name bathroom) + (input <x> drain) + --> + (remove 2) + (write (crlf) |The drain is open, even shoving the bed down it won't close it|)) + +(p name1290 + (location ^name bathroom) + (input plug) + --> + (remove 2) + (write (crlf) |You can't plug it.|)) + +(p name1291 + (location ^name bathroom) + (input <x> plug <y>) + --> + (remove 2) + (write (crlf) |I see no plug here.|)) + +(p name1292 + (location ^name bathroom) + (place ^name bathroom ^state water_running) + (input splash) +--> + (remove 3) + (write (crlf) |Hey, watch it! No splashing around here.|)) + +(p name1293 + (location ^name bathroom ^siton bathtub) + (place ^name bathroom ^state water_running) + (input drown) + (status) + --> + (modify 2 ^state nil) + (remove 3) + (modify 4 ^die t) + (write (crlf) |Adventure a little to tough for you eh?|) + (write (crlf) |Well you did look a little blue, especially after you held your head under|) + (write (crlf) |for ten minutes!|)) + +(p name1294 + (location ^name backroom) + (place ^name backroom ^visited nil) + --> + (write (crlf) |The toilet and the wall have swivled around 180 degrees.|) + (write (crlf) |You are now in a backroom.|) + (write (crlf) |I assume this was for when grand-dad wanted to ... in private.|) + (write (crlf) |There are no doors or windows. Just the toilet.|)) + +(p name1295 + (location ^name backroom) + (input flush) + (place ^name backroom) + --> + (modify 1 ^name bathroom) + (remove 2) + (modify 3 ^visited t) + (write (crlf) |Around you go again.|)) + +(p name1296 + (location ^name backroom) + (input urinate) + --> + (remove 2) + (write (crlf) |Your bladder is empty.|)) + +(p name1297 + (location ^name backroom) + (input shit) + --> + (remove 2) + (write (crlf) |Plop!|)) + +(p name1298 + (location ^name backroom) + (input stand) + --> + (remove 2) + (write (crlf) |There isn't enough room to stand.|)) + +(p name1299 + (location ^name backroom) + (input get up) + --> + (remove 2) + (write (crlf) |I see no up here. Ha ha, only kidding. There isn't room to stand in here.|)) +(p name2000 + (location ^name lawn ^side in ^east 5 ^north 4) + (input ouvre) + (portal ^name large_door ^door closed) + (status ^likes <f>) + --> + (remove 2) + (modify 3 ^name large_door ^door open) + (write (crlf) |The door creaks open.|) + (write (crlf) |A voice from within says: 'Welcome,| <f> |lover.'|)) + +(p name2001 + (location ^name lawn ^side in ^east 5 ^north 4) + (input ouvre) + (portal ^name large_door ^door open) + --> + (remove 2) + (write (crlf) |The door stays open.|)) + +(p name2002 + (location ^name lawn ^side in ^east 5 ^north 4) + (status ^going n) + --> + (remove 2) + (write (crlf) |The door is closed, you bump your nose!|)) + +(p name2003 + (location ^name lawn ^side in ^east 5 ^north 4) + (status ^going n) + (portal ^name large_door ^door open) + --> + (modify 1 ^name foyer ^side nil ^east nil ^north nil) + (modify 2 ^going nil)) + +(p name2004 + (location ^name lawn ^side in ^east 5 ^north 4) + (status ^going n) + (portal ^name large_door ^door open) + (object ^name mattress ^place held) + --> + (modify 2 ^going nil) + (write (crlf) |The mattress won't fit throught the door.|)) + +(p name2005 + (location ^name lawn ^side in ^east 5 ^north 4) + (status ^going n) + (portal ^name large_door ^door open) + (object ^name cube ^place held) +--> + (modify 4 ^place lawn ^side in ^east 5 ^north 4) + (write (crlf) |You stumble over the threshold and drop the cube outside.|)) + +(p name2006 + (location ^name lawn ^side in ^east 5 ^north 4) + (status ^going n) + (portal ^name large_door ^door open) + (object ^name marijuana ^place held) + --> + (write (crlf) |The dope slips from your hand.|) + (modify 4 ^place lawn ^side in ^east 5 ^north 4)) + +(p name2007 + (location ^name lawn ^side in ^east 5 ^north 4) + (input enter) + (status) + --> + (remove 2) + (modify 3 ^going n ^went n)) + +(p name2008 + (location ^name lawn ^side in ^east 5 ^north 4) + --> + (write (crlf) |You are outside a large door in the front of an old mansion.|)) + +(p name2009 + (location ^name lawn ^side in ^east 5 ^north 4) + (input knock) + --> + (remove 2) + (write (crlf) |'Knock! Knock!'|) + (make input ouvre)) + +(p name2010 + (location ^name lawn ^side in ^east 5 ^north 4) + (input ring) + --> + (remove 2) + (write (crlf) |Ding dong!|) + (make input ouvre)) + +(p name2011 + (x 30) + (input ring) + --> + (remove 2) + (write (crlf) |I see no bell here.|)) + +(p name2012 + (location ^name lawn ^side in ^east 5 ^north 4) + (input open) + (portal ^name large_door ^door closed) + --> + (remove 2) + (write (crlf) |Didn't your mother teach you any manners?|) + (write (crlf) |You shouldn't open someones door without their permission!|)) + +(p name2013 + (location ^name lawn ^side in ^east 5 ^north 4) + (portal ^name large_door ^door open) + (input close) + --> + (modify 2 ^door closed) + (remove 3) + (write (crlf) |The door closes.|)) + +(p name2014 + (location ^name lawn ^side in ^east 5 ^north 4) + (status ^sound on) + --> + (write (crlf) |Muffled sounds can be heard from inside.|)) + +(p name2015 + (location ^name foyer) + (place ^name foyer ^visited nil) + --> + (write (crlf) |You are inside of the house in the inner foyer.|) + (write (crlf) |There is a walk-in closet to the west, an entrance to a hall to the north.|)) + +(p name2016 + (location ^name foyer) + (status ^going s) + (portal ^name large_door ^door open) + --> + (modify 2 ^going nil) + (modify 3 ^door closed) + (write (crlf) |Before you can get out the large door slams shut; BOOM!|) + (write (crlf) |Laughter can be heard in the upper floors of the house.|)) + +(p name2017 + (location ^name foyer) + (portal ^name large_door ^door closed) + (input open) + --> + (remove 3) + (write (crlf) |The large door is locked impossible to open.|)) + +(p name2018 + (location ^name foyer) + (status ^going n) + (place ^name foyer) + --> + (modify 2 ^going nil) + (modify 3 ^visited t) + (modify 1 ^name main_hall)) + +(p name2019 + (location ^name foyer) + (portal ^name large_door ^door closed) + (status ^going s) + --> + (modify 3 ^going nil) + (write (crlf) |The door is shut.|)) + +(p name2020 + (location ^name foyer) + (input enter closet) + (status) + --> + (remove 2) + (modify 3 ^going w ^went w)) + +(p name2021 + (location ^name foyer) + (input enter hall) + (status) + --> + (modify 3 ^going n ^went n) + (remove 2)) + +(p name2022 + (location ^name foyer) + (status ^going w) + (place ^name foyer) + --> + (modify 3 ^visited t) + (modify 1 ^name closet) + (modify 2 ^going nil)) + +(p name2023 + (location ^name foyer) + (portal ^name large_door ^door open) + (input close) + --> + (remove 3) + (modify 2 ^door closed) + (write (crlf) |The door closes.|)) + +(p name2024 + (location ^name foyer) + (place ^name foyer ^virgin t) + (time ^realtime <y>) + --> + (modify 2 ^virgin nil) + (modify 3 ^orc_status sweat ^orc_time (compute <y> + 160)) + (write (crlf) |You feel a chill run down your spine, and you doubt your own sanity.|) + (write (crlf) | |) + (write (crlf) |A booming voice proclaims:|) + (write (crlf) |'YOU WON'T GET OUT BY A DOOR.'|) + (write (crlf) |'... at least alive!'|) + (write (crlf) | |) + (write (crlf) |The house is very damp and musty.|)) + +(p name2025 + (location ^name foyer) + (time ^realtime <y> ^orc_time < <y>) + --> + (modify 2 ^orc_time (compute <y> + 20)) + (write (crlf) |A booming voice proclaims:|) + (write (crlf) |'You must be mad to return. If you're not, you will be soon.'|)) + +(p name2026 + (location ^name foyer) + (time ^realtime <y>) + (command ^string eat_it) + --> + (modify 2 ^orc_status nil) + (remove 3)) + +(p name2027 + (location ^name foyer) + (status ^sound on) + --> + (write (crlf) |Some noise is coming from the hall.|)) + +(p name2028 + (location ^name main_hall) + (status ^going s) + (place ^name main_hall) + --> + (modify 1 ^name foyer) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2029 + (location ^name main_hall) + (place ^name main_hall ^visited nil) + --> + (write (crlf) |You are in the main hall.|) + (write (crlf) |The foyer is south.|) + (write (crlf) |The hall extends west and darkens.|) + (write (crlf) |A large room is to the east.|)) + +(p name2030 + (location ^name main_hall) + (place ^name main_hall) + (status ^going w) + --> + (modify 1 ^name dark_hall) + (modify 2 ^visited t) + (modify 3 ^going nil)) + +(p name2031 + (location ^name main_hall) + (status ^going e) + (place ^name main_hall) + --> + (modify 1 ^name library) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2032 + (location ^name main_hall) + (status ^going << u n >>) + (object ^name stairs ^state whole) + (place ^name main_hall) + --> + (modify 1 ^name stairs) + (modify 2 ^going nil) + (modify 4 ^visited t)) + +(p name2033 + (location ^name main_hall) + (status ^going n) + (object ^name stairs ^state collapsed) + (place ^name main_hall) + --> + (modify 1 ^name stairs_debris) + (modify 2 ^going nil) + (modify 4 ^visited t)) + +(p name2034 + (location ^name main_hall) + (status ^sound on) + --> + (write (crlf) |Weird noises are coming from above.|)) + +(p name2035 + (location ^name closet) + (status ^going e) + (place ^name closet) + --> + (modify 1 ^name foyer) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2036 + (location ^name closet) + (place ^name closet ^visited nil) + --> + (write (crlf) |You are in a large closet, you can see all its contents|) + (write (crlf) | by the light from the foyer.|)) + +(p name2037 + (location ^name dark_hall) + (place ^name dark_hall ^visited nil) + --> + (write (crlf) |You are in a poorly lit hall. There is a faint scent of fresh paint.|)) +(p name2038 + (location ^name dark_hall) + (status ^going w) + (place ^name dark_hall) + --> + (modify 1 ^name smelly_room) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2039 + (location ^name dark_hall) + (status ^going e) + (place ^name dark_hall) + --> + (modify 1 ^name main_hall) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2040 + (location ^name stairs) + (place ^name stairs ^visited nil) + --> + (write (crlf) |You are on the landing of the stair case.|) + (write (crlf) |stairs go up and down.|) + (write (crlf) | |) + (write (crlf) |The stairs are squeeky! They seem about to collapse.|)) + +(p name2041 + (location ^name stairs) + (status ^sound on) + --> + (write (crlf) |The sound is coming from above you.|)) + +(p name2042 + (location ^name stairs) + (status ^going u) + (place ^name stairs) + --> + (modify 1 ^name upper_hall) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2043 + (location ^name stairs) + (status ^going d) + (place ^name stairs) + --> + (modify 1 ^name main_hall) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2045 + (location ^name stairs) + (place ^name stairs ^visited t) + --> + (write (crlf) |SQUEEK! These stairs are delicate!|)) + +(p name2046 + (location ^name stairs) + (object ^name stairs ^state whole) + (input jump) + --> + (write (crlf) |CRASH! You've collapsed the stairs.|) + (modify 1 ^name stairs_debris) + (modify 2 ^state collapsed) + (remove 3)) + +(p name2047 + (location ^name smelly_room) + (place ^name smelly_room ^visited nil) + --> + (write (crlf) |You are in a room that smells of paint.|) + (write (crlf) |There are no windows or door except the one you came through.|) + (write (crlf) |The walls are wood panel.|)) + +(p name2048 + (location ^name smelly_room) + (status ^going e) + (place ^name smelly_room) + --> + (modify 1 ^name dark_hall) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2049 + (location ^name library) + (place ^name library ^visited nil) + --> + (write (crlf) |You are in the library. All the walls are lined with books.|) + (write (crlf) |There is a bust of Homer within reach.|)) + +(p name2050 + (location ^name library) + (status ^going w) + (place ^name library) + --> + (modify 1 ^name main_hall) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2051 + (location ^name library) + (input get bust) + --> + (remove 1) + (write (crlf) |The bust is too heavy to carry.|)) + +(p name2052 + (location ^name library) + (input turn bust) + (portal ^name library ^door closed) + --> + (remove 2) + (modify 3 ^door open)) + +(p name2053 + (location ^name library) + (input enter) + (portal ^name library ^door open) + (status) + --> + (remove 2) + (modify 4 ^going e ^went e)) + +(p name2054 + (location ^name library) + (portal ^name library ^door open) + (object ^name wetsuit ^wears t) + (status ^going e) + --> + (modify 4 ^going nil) + (write (crlf) |You can't fit into the opening.|)) + +(p name2055 + (location ^name library) + (portal ^name library ^door open) + (object ^name wetsuit ^place held) + (status ^going e) + --> + (modify 4 ^going nil) + (write (crlf) |Something you're carrying is to big to fit through the door.|)) + +(p name2056 + (location ^name library) + (portal ^name library ^door open) + (status ^going e) + (place ^name library) + --> + (modify 1 ^name secret_stairs) + (modify 3 ^going nil) + (modify 4 ^visited t)) + +(p name2057 + (location ^name library) + (input turn bust) + (portal ^name library ^door open) + --> + (remove 2) + (modify 3 ^door closed) + (write (crlf) |The shelves close.|)) + +(p name2058 + (location ^name library) + (portal ^name library ^door open) + --> + (write (crlf) |The east wall of books is open!|)) + +(p name2059 + (location ^name library) + (input bust) + --> + (remove 2) + (write (crlf) |I'll bust you if you don't watch it.|)) + +(p name2060 + (location ^name library) + (input rub bust) + --> + (remove 2) + (write (crlf) |That isn't very rewarding, nothing happens.|)) + +(p name2061 + (location ^name library) + (input kiss bust) + --> + (remove 2) + (write (crlf) |That might turn on a frog, but homer is unmoved.|)) + +(p name2062 + (location ^name library ^book nil) + (input get book) + --> + (modify 1 ^book t) + (remove 2) + (write (crlf) |You get a book but discover it has only virtual pages.|) + (write (crlf) |The book disappears.|)) + +(p name2063 + (location ^name library ^book t ^book2 nil) + (input get book) + --> + (write (crlf) |The title of the book is 'Vampires I have known'|) + (modify 1 ^book2 t) + (remove 2) + (make object ^name book ^place held)) + +(p name2064 + (location ^name library ^book t ^book2 t) + (input get book) + --> + (remove 2) + (write (crlf) |All the rest of the books are fake.|) + (write (crlf) |They seem to be wood.|)) + +(p name2065 + (location ^name secret_stairs) + (place ^name secret_stairs ^visited nil) + --> + (write (crlf) |You are in the head of a secret staircase.|) + (write (crlf) |The stairs go down. A pole in the room goes through a hole in the ceiling.|)) + +(p name2066 + (location ^name secret_stairs) + (status ^going w) + (portal ^name library ^door open) + (place ^name secret_stairs) + --> + (modify 1 ^name library) + (modify 2 ^going nil) + (modify 4 ^visited t)) + +(p name2067 + (location ^name secret_stairs) + (status ^going d) + (place ^name secret_stairs) + --> + (modify 1 ^name wine_cellar) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2068 + (location ^name secret_stairs) + (portal ^name library ^door closed) + (input open <x>) + --> + (remove 3) + (write (crlf) |The stacks can't be opened from here.|)) + +(p name2069 + (location ^name secret_stairs) + (portal ^name library ^door open) + --> + (write (crlf) |The west wall is open.|)) + +(p name2070 + (location ^name secret_stairs) + (status ^going u) + --> + (modify 2 ^going nil) + (write (crlf) |That isn't a bat pole, ROBIN. You can only come down.|)) + +(p name2071 + (location ^name stairs_debris) + (place ^name stairs_debris ^visited nil) + --> + (write (crlf) |You are on wreckage of the stairs.|) + (write (crlf) |To the south is the main_hall, north is a small opening.|)) + +(p name2072 + (location ^name stairs_debris) + (status ^going s) + (place ^name stairs_debris) + --> + (modify 1 ^name main_hall) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2073 + (location ^name stairs_debris) + (status ^going n) + (place ^name stairs_debris) + --> + (modify 1 ^name back_hall) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2074 + (location ^name back_hall) + (place ^name back_hall ^visited nil) + --> + (write (crlf) |This is the back hall. It connects the kitchen and|) + (write (crlf) |dining room. The kitchen is east and the dining room is west.|)) + +(p name2075 + (location ^name back_hall) + (object ^name stairs ^state collapsed) + --> + (write (crlf) |To the south is the wreckage of the stairs.|)) + +(p name2076 + (location ^name back_hall) + (status ^going e) + (place ^name back_hall) + --> + (modify 1 ^name kitchen) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2077 + (location ^name back_hall) + (status ^going w) + (place ^name back_hall) + --> + (modify 1 ^name dining_room) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2078 + (location ^name back_hall) + (status ^going s) + (place ^name back_hall) + (object ^name stairs ^state collapsed) + --> + (modify 1 ^name stairs_debris) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2079 + (location ^name kitchen) + (place ^name kitchen ^visited nil) + --> + (write (crlf) |You are in a old kitchen. All the windows are|) + (write (crlf) |boarded up. The only exit is west.|) + (write (crlf) | |) + (write (crlf) |There is a refrigerator in the corner.|) + (write (crlf) |A ventilation duct is open over the refrigerator.|)) + +(p name2080 + (location ^name kitchen) + (status ^going w) + (place ^name kitchen) + --> + (modify 1 ^name back_hall) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2081 + (location ^name kitchen) + (input exit) + (status) + --> + (remove 2) + (modify 3 ^going w ^went w)) + +(p name2082 + (location ^name kitchen) + (portal ^name rdoor ^door closed) + --> + (write (crlf) |The refrigirator door is closed.|)) + +(p name2083 + (location ^name kitchen) + (portal ^name rdoor ^door open) + --> + (write (crlf) |The door of the ice box is open.|)) + +(p name2084 + (location ^name kitchen) + (portal ^name rdoor ^door closed) + (input open) + --> + (remove 3) + (modify 2 ^door open)) + +(p name2085 + (location ^name kitchen) + (portal ^name rdoor ^door open) + (input close) +--> + (remove 3) + (modify 2 ^door closed)) + +(p name2086 + (location ^name kitchen) + (portal ^name rdoor ^door open) + (object ^name cube ^place frig) + --> + (write (crlf) |There is a small white cube in the refrigirator.|)) + +(p name2087 + (location ^name kitchen) + (portal ^name rdoor ^door open) + (object ^name cube ^place frig) + (input get cube) + --> + (remove 4) + (write (crlf) |You have a cube.|) + (modify 3 ^place held)) + +(p name2088 + (location ^name kitchen) + (status ^going u) + --> + (modify 2 ^going nil) + (modify 1 ^ontop frig)) + +(p name2089 + (location ^name kitchen ^ontop frig) + --> + (write (crlf) |You are ontop the refrigirator.|) + (write (crlf) |Going down will put you on the floor, going south will put you in the duct.|)) + +(p name2090 + (location ^name kitchen) + (input mount) + --> + (remove 2) + (modify 1 ^ontop frig)) + +(p name2091 + (location ^name kitchen ^ontop frig) + (status ^going s) + (place ^name kitchen) + --> + (modify 2 ^going nil) + (modify 3 ^visited t) + (modify 1 ^name ductf2 ^ontop nil)) + +(p name2092 + (location ^name dining_room) + (place ^name dining room ^visited nil) + --> + (write (crlf) |You are in a large dining room. The ceiling is very high.|) + (write (crlf) |The hall is east.|)) + +(p name2093 + (location ^name dining_room) + (status ^going e) + (place ^name dining_room) + --> + (modify 1 ^name back_hall) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2094 + (location ^name upper_hall) + (place ^name upper_hall ^visited nil) + --> + (write (crlf) |You are at the upper hall. You can see down the|) + (write (crlf) |first steps of some stairs. A circular staircase|) + (write (crlf) |continues up.|) + (write (crlf) | |) + (write (crlf) |There is a dark room to the south,|) + (write (crlf) |a hall to the west, a stone wall to the east,|) + (write (crlf) |and another room to the north.|)) + +(p name2095 + (location ^name upper_hall) + (object ^name stairs ^state collapsed) + (status ^going d) + --> + (modify 3 ^going nil) + (write (crlf) |The stairs are collapsed.|)) + +(p name2096 + (location ^name upper_hall) + (status ^going d) + (place ^name upper_hall) + (object ^name stairs ^state whole) + --> + (modify 1 ^name stairs) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2097 + (location ^name upper_hall) + (status ^going s) + (place ^name upper_hall) + --> + (modify 1 ^name dark_room) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2098 + (location ^name upper_hall) + (status ^going w) + (place ^name upper_hall) + --> + (modify 1 ^name long_hall) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2099 + (location ^name upper_hall) + (status ^going n) + (place ^name upper_hall) + --> + (modify 1 ^name dull_room) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2100 + (location ^name upper_hall) + (status ^going e) + (place ^name upper_hall) + (portal ^name wall ^door open) + --> + (modify 1 ^name secret_room) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2101 + (location ^name upper_hall) + (portal ^name wall ^door closed) + (input << move pull get >> brick) + --> + (remove 3) + (write (crlf) |The brick moves, but can't be removed from the wall.|) + (write (crlf) |A secret panel in the wall opens!|) + (write (crlf) |There is a room ahead.|) + (modify 2 ^door open)) + +(p name2102 + (location ^name upper_hall) + (input close wall) + (portal ^name wall ^door open) + --> + (remove 2) + (modify 3 ^door closed) + (write (crlf) |The wall closes.|)) + +(p name2103 + (location ^name upper_hall) + (status ^going u) + (place ^name upper_hall) + --> + (modify 1 ^name laboratory) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2104 + (location ^name upper_hall) + (status ^sound on) + --> + (write (crlf) |You hear clanking and screams coming from the hall.|)) + +(p name2105 + (location ^name laboratory) + (location ^name laboratory) + (place ^name laboratory ^visited nil) + --> + (write (crlf) |You are in the laboratory. The most notable feature is a huge |) + (write (crlf) |slab in the middle of the room. There is a large |) + (write (crlf) |lever switch. The stairs are the only obvious exit. The ceiling|) + (write (crlf) |is a glass dome painted black, much too high to reach.|)) + +(p name2106 + (location ^name laboratory) + (status ^going d) + (place ^name laboratory) + --> + (modify 1 ^name upper_hall) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2107 + (location ^name laboratory) + (status ^going w) + (place ^name laboratory) + (wall is down) + --> + (modify 1 ^name bar) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2108 + (location ^name laboratory) + (wall is down) + --> + (write (crlf) |The west wall has the shape of a running figure in it.|)) + +(p name2109 + (location ^name laboratory) + (input <B> << lever switch >>) + --> + (remove 2) + (make monster live)) + +(p name2110 + (location ^name laboratory) + (input <x> lever) + (object ^name lever ^state thrown) + --> + (remove 2) + (write (crlf) |The lever is stuck.|)) + +(p name2111 + (location ^name laboratory) + (monster live) + (object ^name monster ^place laboratory) +-(object ^name lever ^state thrown) + --> + (remove 2) + (write (crlf) |The lights dim. A massive door on the east wall|) + (write (crlf) |opens revealing a bank of computers, generators, and misc.|) + (write (crlf) |electronic gear. The generators start to scream.|) + (write (crlf) |The lights dim more. Suddenly sparks start to fly from the|) + (write (crlf) |equipment. The body on the table starts to jerk around.|) + (write (crlf) | |) + (write (crlf) |As suddenly as it started, the generators turn off, the|) + (write (crlf) |wall closes. And everything returns to normal.....|) + (write (crlf) |Then the body rises, removes its sheet and it is a monster.|) + (write (crlf) | |) + (write (crlf) |The monster approaches you and says 'Trick or Treat'|) + (make object ^name lever ^state thrown)) + +(p name2112 + (location ^name laboratory) + (object ^name monster ^place laboratory) +-(object ^name lever ^state thrown) + --> + (write (crlf) |There is the shape of a body on the slab, covered with a sheet.|)) + +(p name2113 + (location ^name laboratory) + (object ^name monster ^place laboratory) + (object ^name candy ^place held) + (object ^name lever ^state thrown) + (input give candy) + --> + (remove 3) + (remove 2) + (remove 5) + (write (crlf) |The monster is pleased.| + |He eats the candy, walks through the west wall|) + (write (crlf) |and disappears.|) + (make wall is down)) + +(p name2114 + (location ^name laboratory) + (object ^name monster ^place laboratory) + (object ^name lever ^state thrown) + (input <x> monster) + --> + (remove 2) + (remove 4) + (write (crlf) |The monster is frightened and holds his breath until he turns|) + (write (crlf) |blue. He then disappears.|)) + +(p name2115 + (location ^name laboratory) + (object ^name lever ^state thrown) + --> + (write (crlf) |The lever has been thrown, and is stuck in that position.|)) + +(p name2116 + (location ^name laboratory) + (object ^name football ^place held) + (input kick football) + --> + (remove 3) + (write (crlf) |The football goes crashing through the glass dome.|) + (modify 2 ^place lawn ^side in ^east 7 ^north 4) + (make object ^name dome ^state broken)) + +(p name2117 + (location ^name laboratory) + (object ^name football ^place held) + (object ^name rope ^state tied ^tied football) + (input kick football <p>) + --> + (remove 4) + (write (crlf) |Kicking the football tears the rope off of it.|) + (write (crlf) |The football goes crashing through the glass dome.|) + (modify 3 ^state untied) + (modify 2 ^place lawn ^side in ^east 7 ^north 4) + (make object ^name dome ^state broken)) + +(p name2118 + (location ^name laboratory) + (object ^name Dracula ^place laboratory) + (object ^name dome ^state broken) + --> + (remove 2) + (write (crlf) |The bat flies through the hole in the dome and escapes.|)) + +(p name2119 + (location ^name laboratory) + (object ^name Dracula ^place laboratory) + --> + (write (crlf) |There is a bat flying around in the dome, too high to reach.|)) + +(p name2120 + (location ^name laboratory) + (object ^name Dracula ^place laboratory) + (input get Dracula) + --> + (remove 3) + (write (crlf) |I said the bat was too high to reach, even on a stool.|)) + +(p name2121 + (location ^name laboratory) + (object ^name Dracula ^place laboratory) + (input get bat) + --> + (remove 3) + (write (crlf) |The bat is much too high for you to get.|)) + +(p name2122 + (location ^name laboratory) + (object ^name Dracula ^place laboratory) + (object ^name dome ^state broken) + (time ^morning t) + --> + (remove 2) + (make object ^name ring ^place laboratory ^treasure t) + (write (crlf) |The sun's rays cause the bat to shrivel. Something falls to the floor.|)) + +(p name2123 + (object ^name Dracula ^place laboratory) + (object ^name dome ^state broken) + (time ^morning t) + --> + (remove 1) + (make object ^name ring ^place laboratory ^treasure t)) + +(p name2124 + (location ^name laboratory) + (object ^name monster ^place laboratory) + (object ^name lever ^state thrown) + (place ^name laboratory ^visited t) + --> + (write (crlf) |The monster is drooling on himself, saying 'Trick or Treat'|)) + +(p name2125 + (location ^name laboratory) + (object ^name monster ^place laboratory) + (object ^name lever ^state thrown) + (input give <x>) + --> + (remove 4) + (write (crlf) |The monster doesn't like | <x> |. |) + (write (crlf) |He is getting very angry.|)) + +(p name2126 + (location ^name laboratory) + (object ^name monster ^place laboratory) + (object ^name lever ^state thrown) + (input give monster <x>) + --> + (remove 4) + (make input give <x>)) + +(p name2127 + (location ^name laboratory) + (object ^name monster ^place laboratory) + (object ^name lever ^state thrown) + (input give <x> to monster) + --> + (remove 4) + (make input give <x>)) + +(p name2128 + (location ^name laboratory) + (object ^name monster ^place laboratory) + (object ^name lever ^state thrown) + (input throw <x>) + --> + (remove 4) + (make input give <x>)) + +(p name2129 + (location ^name laboratory) + (object ^name dome ^state broken) + (time ^morning t) + --> + (write (crlf) |Light shows throught the hole.|)) + +(p name2130 + (location ^name laboratory) + (object ^name matches ^place laboratory) + (time ^morning t) + --> + (write (crlf) |Even in the sun light the matches don't dry.|) + (write (crlf) |The laboratory is damp and musty.|)) + +(p name2131 + (location ^name laboratory) + (input dry matches) + --> + (remove 2) + (write (crlf) |The laboratory is very damp.|)) + +(p name2132 + (location ^name laboratory) + (object ^name dome ^state broken) + (time ^morning nil) + --> + (write (crlf) |You can see the moon through the dome.|)) + +(p name2133 + (location ^name laboratory) + (object ^name monster ^place laboratory) + (object ^name cube ^place held) + (object ^name lever ^state thrown) + (input give cube) + --> + (remove 2) + (remove 3) + (remove 5) + (write (crlf) |The monster eats the cube. He then starts saying 'ohhh, ahhhh'.|) + (write (crlf) |'Out of sight man.' Then he jumps straight up through the dome.|) + (make object ^name dome ^state broken)) + +(p name2134 + (location ^name bar) + (location ^name bar) + (place ^name bar ^visited nil) + --> + (write (crlf) |You are in a bar. There isn't any booze.|)) + +(p name2135 + (location ^name bar) + (status ^going e) + (place ^name bar) + --> + (modify 1 ^name laboratory) + (modify 2 ^going nil) + (modify 3 ^visited t)) + +(p name2136 + (location ^name wine_racks) + --> + (write (crlf) |You are in rows of wine racks that stretch out of sight in all directions.|)) + +(p name2137 + (location ^name wine_racks ^east <e>) + (status ^going e) + --> + (remove 1) + (modify 2 ^going nil) + (modify 1 ^name wine_racks ^east (compute 1 + <e>))) + diff --git a/contrib/ops/mab.ops b/contrib/ops/mab.ops new file mode 100644 index 000000000..9632ad56e --- /dev/null +++ b/contrib/ops/mab.ops @@ -0,0 +1,174 @@ +(literalize start) + +(literalize monkey + at + on + holds) + +(literalize object + name + at + weight + on) + +(literalize goal + status + type + object + to) + +(p mb1 + (goal ^status active ^type holds ^object <w>) + (object ^name <w> ^at <p> ^on ceiling) + --> + (make goal ^status active ^type move ^object ladder ^to <p>)) + + +(p mb2 + (goal ^status active ^type holds ^object <w>) + (object ^name <w> ^at <p> ^on ceiling) + (object ^name ladder ^at <p>) + --> + (make goal ^status active ^type on ^object ladder)) + +(p mb4 + (goal ^status active ^type holds ^object <w>) + (object ^name <w> ^at <p> ^on ceiling) + (object ^name ladder ^at <p>) + (monkey ^on ladder ^holds nil) + --> + (write (crlf) grab <w>) + (modify 4 ^holds <w>) + (modify 1 ^status satisfied)) + +(p mb3 + (goal ^status active ^type holds ^object <w>) + (object ^name <w> ^at <p> ^on ceiling) + (object ^name ladder ^at <p>) + (monkey ^on ladder) + --> + (make goal ^status active ^type holds ^object nil)) + +(p mb5 + (goal ^status active ^type holds ^object <w>) + (object ^name <w> ^at <p> ^on floor) + --> + (make goal ^status active ^type walk-to ^object <p>)) + +(p mb7 + (goal ^status active ^type holds ^object <w>) + (object ^name <w> ^at <p> ^on floor) + (monkey ^at <p> ^holds nil) + --> + (write (crlf) grab <w>) + (modify 3 ^holds <w>) + (modify 1 ^status satisfied)) + +(p mb6 + (goal ^status active ^type holds ^object <w>) + (object ^name <w> ^at <p> ^on floor) + (monkey ^at <p>) + --> + (make goal ^status active ^type holds ^object nil)) + +(p mb8 + (goal ^status active ^type move ^object <o> ^to <p>) + (object ^name <o> ^weight light ^at <> <p>) + --> + (make goal ^status active ^type holds ^object <o>)) + + +(p mb9 + (goal ^status active ^type move ^object <o> ^to <p>) + (object ^name <o> ^weight light ^at <> <p>) + (monkey ^holds <o>) + --> + (make goal ^status active ^type walk-to ^object <p>)) + + +(p mb10 + (goal ^status active ^type move ^object <o> ^to <p>) + (object ^name <o> ^weight light ^at <p>) + --> + (modify 1 ^status satisfied)) + + +(p mb11 + (goal ^status active ^type walk-to ^object <p>) + --> + (make goal ^status active ^type on ^object floor)) + +(p mb12 + (goal ^status active ^type walk-to ^object <p>) + (monkey ^on floor ^at {<c> <> <p>} ^holds nil) + --> + (write (crlf) walk to <p>) + (modify 2 ^at <p>) + (modify 1 ^status satisfied)) + + +(p mb13 + (goal ^status active ^type walk-to ^object <p>) + (monkey ^on floor ^at {<c> <> <p>} ^holds {<w> <> nil}) + (object ^name <w>) + --> + (write (crlf) walk to <p>) + (modify 2 ^at <p>) + (modify 3 ^at <p>) + (modify 1 ^status satisfied)) + +(p mb14 + (goal ^status active ^type on ^object floor) + (monkey ^on {<x> <> floor}) + --> + (write (crlf) jump onto the floor) + (modify 2 ^on floor) + (modify 1 ^status satisfied)) + +(p mb15 + (goal ^status active ^type on ^object <o>) + (object ^name <o> ^at <p>) + --> + (make goal ^status active ^type walk-to ^object <p>)) + + + +(p mb16 + (goal ^status active ^type on ^object <o>) + (object ^name <o> ^at <p>) + (monkey ^at <p>) + --> + (make goal ^status active ^type holds ^object nil)) + + +(p mb17 + (goal ^status active ^type on ^object <o>) + (object ^name <o> ^at <p>) + (monkey ^at <p> ^holds nil) + --> + (write (crlf) climb onto <o>) + (modify 3 ^on <o>) + (modify 1 ^status satisfied)) + +(p mb18 + (goal ^status active ^type holds ^object nil) + (monkey ^holds {<x> <> nil}) + --> + (write (crlf) drop <x>) + (modify 2 ^holds nil) + (modify 1 ^status satisfied)) + +(p mb19 + (goal ^status active) + --> + (modify 1 ^status not-processed)) + +(p t1 + (start) + --> + (make monkey ^at 5-7 ^on couch) + (make object ^name couch ^at 5-7 ^weight heavy) + (make object ^name bananas ^on ceiling ^at 2-2) + (make object ^name ladder ^on floor ^at 9-5 ^weight light) + (make goal ^status active ^type holds ^object bananas)) + diff --git a/contrib/ops/myw.ops b/contrib/ops/myw.ops new file mode 100644 index 000000000..f78a299b3 --- /dev/null +++ b/contrib/ops/myw.ops @@ -0,0 +1,9029 @@ +(literalize unit unit-name file-name) + +(literalize pin net-name pin-name external-net-name external-pin-name pin-left-x pin-left-y fixed-pin pin-x pin-y pin-layer pin-layer-constraint pin-channel-side pin-is-attached) + +(literalize channel channel-bottom-left-x channel-bottom-left-y channel-top-right-x channel-top-right-y channel-width channel-length no-of-left-pins no-of-right-pins no-of-bottom-pins no-of-top-pins right-fixed left-fixed bottom-fixed top-fixed channel-type no-of-fixed-sides) + +(literalize net net-name parent-name net-no-of-pins net-left-x net-left-y net-right-x net-right-y no-of-left-pins no-of-right-pins no-of-top-pins no-of-bottom-pins net-is-routed left-most-pin-name right-most-pin-name bottom-most-pin-name top-most-pin-name fixed-net net-layer external-net-name no-of-inter max-no-of-via) + +(literalize layer-info layer-name layer-order layer-priority) + +(literalize context present previous saved) + +(literalize ff net-name pin-name grid-layer grid-x grid-y came-from can-chng-layer) + +(literalize next-net-to-be-routed net-name no-of-attached-pins criteria) + +(literalize to-be-routed net-name no-of-attached-pins) + +(literalize occupied x y m) + +(literalize constraint constraint-type constraint-relation channel-side constraint-reason net-name-1 net-name-2 pin-name-1 pin-name-2 seg-id-1 seg-id-2) + +(literalize congestion direction coordinate no-of-nets extra-nets como) + +(literalize intersection net-name direction min max) + +(literalize horizontal min max com compo commo layer status min-net max-net net-name pin-name) + +(literalize vertical min max com compo commo layer status min-net max-net net-name pin-name) + +(literalize horizontal-s net-name min max com id top-count bot-count sum difference absolute side) + +(literalize vertical-s net-name min max com id top-count bot-count sum difference absolute side) + +(literalize total net-name row-col coor level-pins total-pins cong min-xy max-xy last-pin last-xy nets) + +(literalize tree net-name orientation com min max count id) + +(vector-attribute nets) + +(p p327 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max>) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min { <hmin> <= <gx> } ^max { <hmax> >= <gx> > <min> } ^com 1 ^id <id>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <> <id>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x { >= <hmin> <= <hmax> } ^pin-channel-side bottom) + (constraint ^constraint-type vertical ^seg-id-1 <id>) + (total ^net-name <> <nn>) + - (total-verti <nn>) + --> + (remove <t>) +) + +(p p328 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max>) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min { <hmin> <= <gx> < <max> } ^max { <hmax> >= <gx> } ^com <lr> ^id <id>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <lr> ^id <> <id>) + (last-row <lr>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x { >= <hmin> <= <hmax> } ^pin-channel-side top) + (constraint ^constraint-type vertical ^seg-id-2 <id>) + (total ^net-name <> <nn>) + - (total-verti <nn>) + --> + (remove <t>) +) + +(p p329 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max>) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> } ^max { <vmax> >= <gy> > <min> } ^com 1 ^id <id>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <> <id>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-y { >= <vmin> <= <vmax> } ^pin-channel-side left) + (constraint ^constraint-type horizontal ^seg-id-1 <id>) + (total ^net-name <> <nn>) + - (total-verti <nn>) + --> + (remove <t>) +) + +(p p330 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max>) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> < <max> } ^max { <vmax> >= <gy> } ^com <lc> ^id <id>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <lc> ^id <> <id>) + (last-col <lc>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-y { >= <vmin> <= <vmax> } ^pin-channel-side right) + (constraint ^constraint-type horizontal ^seg-id-2 <id>) + (total ^net-name <> <nn>) + - (total-verti <nn>) + --> + (remove <t>) +) + +(p p331 + { <c> (context ^present modify-total) } + --> + (modify <c> ^present delete-total) +) + +(p p332 + { <c> (context ^present delete-total) } + - (total) + --> + (remove <c>) + (make context ^previous find-no-of-pins-on-a-row-col) +) + +(p p333 + { <c> (context ^present extend-total) } + (last-row <lr>) + --> + (make maximum-total 0 0 0 1 0 <lr> 0) + (make merge-direction left) + (modify <c> ^present merge) + (make eliminate-total) +) + +(p p334 + { <c> (context ^present delete-total) } + --> + (modify <c> ^present extend-total) +) + +(p p335 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min { <hmin> <= <gx> } ^max { <hmax> >= <gx> } ^com 1 ^id <id> ^absolute <a> ^sum <s>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <> <id>) + - (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <hmin> ^max-xy <hmax> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x { >= <hmin> <= <hmax> } ^pin-channel-side bottom) + --> + (make (substr <t> 1 inf) ^min-xy <hmin> ^max-xy <hmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <hmin> <hmax>) +) + +(p p336 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min { <hmin> <= <gx> } ^max { <hmax> >= <gx> } ^com <lr> ^id <id> ^absolute <a> ^sum <s>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <lr> ^id <> <id>) + - (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <hmin> ^max-xy <hmax> ^last-pin checked) + (last-row <lr>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x { >= <hmin> <= <hmax> } ^pin-channel-side top) + --> + (make (substr <t> 1 inf) ^min-xy <hmin> ^max-xy <hmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <hmin> <hmax>) +) + +(p p337 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> } ^max { <vmax> >= <gy> } ^com 1 ^id <id> ^absolute <a> ^sum <s>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <> <id>) + - (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <vmin> ^max-xy <vmax> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-y { >= <vmin> <= <vmax> } ^pin-channel-side left) + --> + (make (substr <t> 1 inf) ^min-xy <vmin> ^max-xy <vmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <vmin> <vmax>) +) + +(p p338 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> } ^max { <vmax> >= <gy> } ^com <lc> ^id <id> ^absolute <a> ^sum <s>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <lc> ^id <> <id>) + - (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <vmin> ^max-xy <vmax> ^last-pin checked) + (last-col <lc>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-y { >= <vmin> <= <vmax> } ^pin-channel-side right) + --> + (make (substr <t> 1 inf) ^min-xy <vmin> ^max-xy <vmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <vmin> <vmax>) +) + +(p p339 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min 1 ^max { <hmax> >= <gx> } ^com <com> ^id <id> ^absolute <a> ^sum <s>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <garb> ^id <> <id>) + - (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy 1 ^max-xy <hmax> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x 0 ^pin-y <com> ^pin-channel-side left) + --> + (make (substr <t> 1 inf) ^min-xy 1 ^max-xy <hmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> 1 <hmax>) +) + +(p p340 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min { <hmin> <= <gx> } ^max <lc> ^com <com> ^id <id> ^absolute <a> ^sum <s>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <garb> ^id <> <id>) + - (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <hmin> ^max-xy <lc> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-y <com> ^pin-channel-side right) + (last-col <lc>) + --> + (make (substr <t> 1 inf) ^min-xy <hmin> ^max-xy <lc> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <hmin> <lc>) +) + +(p p341 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min 1 ^max { <vmax> >= <gy> } ^com <com> ^id <id> ^absolute <a> ^sum <s>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <garb> ^id <> <id>) + - (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy 1 ^max-xy <vmax> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x <com> ^pin-channel-side bottom) + --> + (make (substr <t> 1 inf) ^min-xy 1 ^max-xy <vmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> 1 <vmax>) +) + +(p p342 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> } ^max <lr> ^com <com> ^id <id> ^absolute <a> ^sum <s>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <garb> ^id <> <id>) + - (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <vmin> ^max-xy <lr> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x <com> ^pin-channel-side top) + (last-row <lr>) + --> + (make (substr <t> 1 inf) ^min-xy <vmin> ^max-xy <lr> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <vmin> <lr>) +) + +(p p343 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (total ^net-name <nn> ^row-col <rc> ^coor <y> ^last-pin checked) + --> + (remove <t>) +) + +(p p344 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + --> + (remove <t>) +) + +(p p345 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (net ^net-name <nn> ^net-no-of-pins 2) + --> + (modify <t> ^last-pin checked ^nets <nn> <min> <max>) +) + +(p p346 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + - (total ^last-pin checked) + --> + (modify <t> ^last-pin checked ^nets <nn> <min> <max>) +) + +(p p347 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max>) } + (last-col <lc>) + (horizontal-s ^net-name { <nn1> <> <nn> } ^min 1 ^max { >= <min> <> <lc> } ^com <y> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x 0 ^pin-y <y>) + - (pin ^net-name <nn> ^pin-y <y> ^pin-channel-side right) + --> + (remove <t>) +) + +(p p348 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <tmin> ^max-xy <max>) } + (last-col <lc>) + (horizontal-s ^net-name { <nn1> <> <nn> } ^min 1 ^max { <maxs> <> <lc> } ^com <y> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x 0 ^pin-y <y>) + (vertical ^net-name <nn> ^min <= <y> ^max >= <y> ^com { <min> > 1 <= <maxs> }) + - (vertical ^net-name <nn> ^min <= <y> ^max >= <y> ^com < <min>) + { <h> (horizontal ^net-name <nn1> ^min 0 ^max { <hmax> < <min> } ^com <y> ^layer <lay>) } + { <ff> (ff ^net-name <nn1> ^grid-x <hmax> ^grid-y <y> ^grid-layer <lay> ^came-from west) } + { <h1> (horizontal ^net-name nil ^min <hmax> ^max > <hmax> ^com <y> ^layer <lay>) } + - (pin ^net-name <nn> ^pin-y <y>) + - (vertical ^status nil ^net-name { <> <nn1> <> nil } ^min <= <y> ^max >= <y> ^com <min> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn1> <> nil } ^min <= <min> ^max >= <min> ^com <y> ^layer <lay>) + --> + (remove <t>) + (modify <h> ^max <min>) + (modify <h1> ^min <min> ^min-net <nn1>) + (modify <ff> ^grid-x <min> ^can-chng-layer nil) +) + +(p p349 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max>) } + (last-col <lc>) + (horizontal-s ^net-name { <nn1> <> <nn> } ^min { <= <max> <> 1 } ^max <lc> ^com <y> ^id <=> 1) + (pin ^net-name <nn1> ^pin-y <y> ^pin-channel-side right) + - (pin ^net-name <nn> ^pin-y <y> ^pin-channel-side left) + --> + (remove <t>) +) + +(p p350 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <tmax>) } + (last-col <lc>) + (horizontal-s ^net-name { <nn1> <> <nn> } ^min { <mins> <> 1 } ^max <lc> ^com <y> ^id <=> 1) + (pin ^net-name <nn1> ^pin-y <y> ^pin-channel-side right) + (vertical ^net-name <nn> ^min <= <y> ^max >= <y> ^com { <max> >= <mins> < <lc> }) + - (vertical ^net-name <nn> ^min <= <y> ^max >= <y> ^com > <max>) + { <h> (horizontal ^net-name <nn1> ^min { <hmin> > <max> } ^max <garb> ^com <y> ^layer <lay>) } + { <ff> (ff ^net-name <nn1> ^grid-x <hmin> ^grid-y <y> ^grid-layer <lay> ^came-from east) } + { <h1> (horizontal ^net-name nil ^min < <max> ^max <hmin> ^com <y> ^layer <lay>) } + - (pin ^net-name <nn> ^pin-y <y>) + - (vertical ^status nil ^net-name { <> <nn1> <> nil } ^min <= <y> ^max >= <y> ^com <max> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn1> <> nil } ^min <= <max> ^max >= <max> ^com <y> ^layer <lay>) + --> + (remove <t>) + (modify <h> ^min <max>) + (modify <h1> ^max <max> ^max-net <nn1>) + (modify <ff> ^grid-x <max> ^can-chng-layer nil) +) + +(p p351 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max>) } + (last-row <lr>) + (vertical-s ^net-name { <nn1> <> <nn> } ^min 1 ^max { >= <min> <> <lr> } ^com <x> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x <x> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x <x> ^pin-channel-side top) + --> + (remove <t>) +) + +(p p352 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <tmin> ^max-xy <max>) } + (last-row <lr>) + (vertical-s ^net-name { <nn1> <> <nn> } ^min 1 ^max { <maxs> <> <lr> } ^com <x> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x <x> ^pin-channel-side bottom) + (horizontal ^net-name <nn> ^min <= <x> ^max <x> ^com { <min> > 1 <= <maxs> }) + - (horizontal ^net-name <nn> ^min <= <x> ^max <x> ^com < <min>) + { <v> (vertical ^net-name <nn1> ^min 0 ^max { <vmax> < <min> } ^com <x> ^layer <lay>) } + { <ff> (ff ^net-name <nn1> ^grid-x <x> ^grid-y <vmax> ^grid-layer <lay> ^came-from south) } + { <v1> (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <x> ^layer <lay>) } + - (pin ^net-name <nn> ^pin-x <x>) + - (vertical ^status nil ^net-name { <> <nn1> <> nil } ^min <= <min> ^max >= <min> ^com <x>) + - (horizontal ^status nil ^net-name { <> <nn1> <> nil } ^min <= <x> ^max >= <x> ^com <min>) + --> + (remove <t>) + (modify <v> ^max <min>) + (modify <v1> ^min <min> ^min-net <nn1>) + (modify <ff> ^grid-y <min> ^can-chng-layer nil) +) + +(p p353 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max>) } + (last-row <lr>) + (vertical-s ^net-name { <nn1> <> <nn> } ^min { <= <max> <> 1 } ^max <lr> ^com <x> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x <x> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x <x> ^pin-channel-side bottom) + --> + (remove <t>) +) + +(p p354 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <tmax>) } + (last-row <lr>) + (vertical-s ^net-name { <nn1> <> <nn> } ^min { <mins> <> 1 } ^max <lr> ^com <x> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x <x> ^pin-channel-side top) + (horizontal ^net-name <nn> ^min <= <x> ^max >= <x> ^com { <max> >= <mins> < <lr> }) + - (horizontal ^net-name <nn> ^min <= <x> ^max >= <x> ^com > <max>) + { <v> (vertical ^net-name <nn1> ^min { <vmin> > <max> } ^max <garb> ^com <x> ^layer <lay>) } + { <ff> (ff ^net-name <nn1> ^grid-x <x> ^grid-y <vmin> ^grid-layer <lay> ^came-from north) } + { <v1> (vertical ^net-name nil ^min < <vmin> ^max <vmin> ^com <x> ^layer <lay>) } + - (pin ^net-name <nn> ^pin-x <x>) + - (vertical ^status nil ^net-name { <> <nn1> <> nil } ^min <= <max> ^max >= <max> ^com <x>) + - (horizontal ^status nil ^net-name { <> <nn1> <> nil } ^min <= <x> ^max >= <x> ^com <max>) + --> + (remove <t>) + (modify <v> ^min <max>) + (modify <v1> ^max <max> ^max-net <nn1>) + (modify <ff> ^grid-y <max> ^can-chng-layer nil) +) + +(p p355 + (context ^present extend-total) + - (switch-box) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-xy <id>) } + (last-row > <y>) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <id>) + - (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com <y>) + - (horizontal ^net-name <nn> ^min <= <min> ^max >= <min> ^com <y>) + - (horizontal ^net-name <nn> ^min <= <max> ^max >= <max> ^com <y>) + - (horizontal ^net-name <nn> ^min >= <min> ^max <= <max> ^com <y>) + (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com > <y>) + - (ff ^net-name <nn> ^grid-x { >= <min> <= <max> } ^grid-y <y> ^pin-name >= 1000) + --> + (modify <t> ^coor (compute <y> + 1)) +) + +(p p356 + (context ^present extend-total) + - (switch-box) + { <t> (total ^net-name <nn> ^row-col row ^coor { <y> > 0 } ^min-xy <min> ^max-xy <max> ^last-xy <id>) } + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <lr> ^id <id>) + (last-row <lr>) + - (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com <y>) + - (horizontal ^net-name <nn> ^min <= <min> ^max >= <min> ^com <y>) + - (horizontal ^net-name <nn> ^min <= <max> ^max >= <max> ^com <y>) + - (horizontal ^net-name <nn> ^min >= <min> ^max <= <max> ^com <y>) + (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com < <y>) + - (ff ^net-name <nn> ^grid-x { >= <min> <= <max> } ^grid-y <y> ^pin-name >= 1000) + --> + (modify <t> ^coor (compute <y> - 1)) +) + +(p p357 + (context ^present extend-total) + - (switch-box) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-xy <id>) } + (last-col > <x>) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <id>) + - (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com <x>) + - (vertical ^net-name <nn> ^min <= <min> ^max >= <min> ^com <x>) + - (vertical ^net-name <nn> ^min <= <max> ^max >= <max> ^com <x>) + - (vertical ^net-name <nn> ^min >= <min> ^max <= <max> ^com <x>) + (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com > <x>) + - (ff ^net-name <nn> ^grid-x <x> ^grid-y { >= <min> <= <max> } ^pin-name >= 1000) + --> + (modify <t> ^coor (compute <x> + 1)) +) + +(p p358 + (context ^present extend-total) + - (switch-box) + { <t> (total ^net-name <nn> ^row-col col ^coor { <x> > 0 } ^min-xy <min> ^max-xy <max> ^last-xy <id>) } + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <lc> ^id <id>) + (last-col <lc>) + - (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com <x>) + - (vertical ^net-name <nn> ^min <= <min> ^max >= <min> ^com <x>) + - (vertical ^net-name <nn> ^min <= <max> ^max >= <max> ^com <x>) + - (vertical ^net-name <nn> ^min >= <min> ^max <= <max> ^com <x>) + (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com < <x>) + - (ff ^net-name <nn> ^grid-x <x> ^grid-y { >= <min> <= <max> } ^pin-name >= 1000) + --> + (modify <t> ^coor (compute <x> - 1)) +) + +(p p359 + (context ^present extend-total) + (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-xy <id>) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <id>) + (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com <y>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y { <gy> < <y> } ^grid-layer <lay> ^pin-name <pn>) } + { <v> (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { <vmax> >= <y> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <y> ^max >= <y> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <y> ^layer <lay>) + --> + (make vertical ^min <y> ^max <vmax> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn> ^max-net <mn>) + (modify <v> ^max <gy> ^max-net <nn>) + (make vertical ^min <gy> ^max <y> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^net-name <nn> ^pin-name <pn>) + (modify <ff> ^grid-y <y> ^came-from south ^can-chng-layer nil) +) + +(p p360 + (context ^present extend-total) + (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-xy <id>) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <lr> ^id <id>) + (last-row <lr>) + (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com <y>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y { <gy> > <y> } ^grid-layer <lay> ^pin-name <pn>) } + { <v> (vertical ^net-name nil ^min { <vmin> <= <y> } ^max { <vmax> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <y> ^max >= <y> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <y> ^layer <lay>) + --> + (make vertical ^min <gy> ^max <vmax> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn> ^max-net <mn>) + (modify <v> ^max <y> ^max-net <nn>) + (make vertical ^min <y> ^max <gy> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^net-name <nn> ^pin-name <pn>) + (modify <ff> ^grid-y <y> ^came-from north ^can-chng-layer nil) +) + +(p p361 + (context ^present extend-total) + (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-xy <id>) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <id>) + (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com <x>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx> < <x> } ^grid-y { <gy> >= <min> <= <max> } ^grid-layer <lay> ^pin-name <pn>) } + { <v> (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> >= <x> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <x> ^max >= <x> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <x> ^layer <lay>) + --> + (make horizontal ^min <x> ^max <hmax> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn> ^max-net <mn>) + (modify <v> ^max <gx> ^max-net <nn>) + (make horizontal ^min <gx> ^max <x> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^net-name <nn> ^pin-name <pn>) + (modify <ff> ^grid-x <x> ^came-from west ^can-chng-layer nil) +) + +(p p362 + (context ^present extend-total) + (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-xy <id>) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <lc> ^id <id>) + (last-col <lc>) + (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com <x>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx> > <x> } ^grid-y { <gy> >= <min> <= <max> } ^grid-layer <lay> ^pin-name <pn>) } + { <v> (horizontal ^net-name nil ^min { <hmin> <= <x> } ^max { <hmax> >= <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <x> ^max >= <x> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <x> ^layer <lay>) + --> + (make horizontal ^min <gx> ^max <hmax> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn> ^max-net <mn>) + (modify <v> ^max <x> ^max-net <nn>) + (make horizontal ^min <x> ^max <gx> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^net-name <nn> ^pin-name <pn>) + (modify <ff> ^grid-x <x> ^came-from east ^can-chng-layer nil) +) + +(p p490 + { <c> (context ^present separate) } + --> + (modify <c> ^present reconnect) +) + +(p p491 + { <c> (context ^present reconnect) } + --> + (modify <c> ^present form-verti) +) + +(p p492 + { <c> (context ^present form-verti) } + --> + (modify <c> ^present partial-route) +) + +(p p493 + { <c> (context ^present partial-route) } + --> + (modify <c> ^present extend-pins) +) + +(p p494 + { <c1> (context ^present extend-pins) } + --> + (modify <c1> ^present nil ^previous extend-pins) +) + +(p p495 + { <c1> (context ^previous extend-pins) } + --> + (make switch-box) + (make context ^present propagate-constraint) + (remove <c1>) +) + +(p p496 + { <c1> (context ^previous extend-pins) } + (channel ^no-of-left-pins 0 ^no-of-right-pins 0) + --> + (remove <c1>) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p497 + { <c1> (context ^previous extend-pins) } + (channel ^no-of-bottom-pins 0 ^no-of-top-pins 0) + --> + (remove <c1>) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p498 + (context ^previous propagate-constraint) + (net ^net-is-routed <> yes) + --> + (remove 1) + (make context ^present lshape1) +) + +(p p499 + (context ^present lshape1) + --> + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p500 + { <c> (context ^previous find-no-of-pins-on-a-row-col) } + - (total) + - (extend-ff-tried) + --> + (remove <c>) + (make context ^present lshape4) +) + +(p p501 + { <c> (context ^present lshape4) } + --> + (remove <c>) + (make extend-ff-tried) + (make context ^present extend-ff) +) + +(p p502 + { <c> (context ^present extend-ff) } + --> + (remove <c>) + (make context ^previous extend-ff) +) + +(p p503 + { <c> (context ^previous extend-ff) } + - (extended-ff) + --> + (remove <c>) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p504 + { <c> (context ^previous extend-ff) } + { <e> (extended-ff) } + { <ex> (extend-ff-tried) } + --> + (remove <c> <e> <ex>) + (make context ^present find-no-of-pins-on-a-row-col) + (make goal cleanup extended-ff) +) + +(p p505 + (context ^previous find-no-of-pins-on-a-row-col) + - (total) + (extend-ff-tried) + - (total-verti) + --> + (remove 1) + (make context ^present find-no-of-vcg-hcg) + (make goal cleanup counted-verti) +) + +(p p506 + (context ^previous find-no-of-pins-on-a-row-col) + - (total) + (total-verti) + - (verti-has-loop) + --> + (remove 1) + (make verti-has-loop) + (make context ^present choose-between-total-verti) +) + +(p p507 + (context ^previous find-no-of-pins-on-a-row-col) + - (total) + (total-verti) + (verti-has-loop) + --> + (make context ^present extend-h-v-s) + (make goal cleanup total-verti) + (make goal cleanup counted-verti) + (make goal cleanup extend-ff-tried) + (remove 1 3) +) + +(p p508 + (context ^present choose-between-total-verti) + - (total-verti ^4 > 0) + --> + (modify 1 ^present extend-h-v-s) + (make goal cleanup counted-verti) +) + +(p p509 + (context ^previous find-no-of-vcg-hcg) + - (total-verti) + --> + (remove 1) + (make context ^present extend-h-v-s) +) + +(p p510 + (context ^present loose-constraint) + --> + (make context ^present lshape2) + (remove 1) +) + +(p p511 + (context ^present lshape2) + --> + (modify 1 ^present lshape3) +) + +(p p512 + (context ^present lshape3) + --> + (remove 1) + (make context ^present random0) +) + +(p p513 + (context ^present random0) + --> + (remove 1) + (make context ^present random1) +) + +(p p514 + (context ^present remove-routed-net-segments) + - (net ^net-is-routed <> yes) + - (horizontal ^net-name <> nil ^status nil) + - (vertical ^net-name <> nil ^status nil) + --> + (write (crlf) | Finished with the routing.|) + (halt) +) + +(p p1 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^com <min>) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side top) + - (horizontal-s ^net-name <nn> ^min <= <px> ^max >= <px> ^id <> <id>) + (pin ^net-name <> <nn> ^pin-x <min> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x <px> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { < <px> > <min> }) + (pin ^net-name <nn> ^pin-x > <px> ^pin-channel-side top) + --> + (modify <h> ^min <px>) + (make horizontal-s ^net-name <nn> ^min <min> ^max <px> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p2 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^com <min>) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side bottom) + - (horizontal-s ^net-name <nn> ^min <= <px> ^max >= <px> ^id <> <id>) + (pin ^net-name <> <nn> ^pin-x <min> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x <px> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { < <px> > <min> }) + (pin ^net-name <nn> ^pin-x > <px> ^pin-channel-side bottom) + --> + (modify <h> ^min <px>) + (make horizontal-s ^net-name <nn> ^min <min> ^max <px> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p3 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^com <max>) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side top) + - (horizontal-s ^net-name <nn> ^min <= <px> ^max >= <px> ^id <> <id>) + (pin ^net-name <> <nn> ^pin-x <max> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x <px> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { < <max> > <px> }) + (pin ^net-name <nn> ^pin-x < <px> ^pin-channel-side top) + --> + (modify <h> ^max <px>) + (make horizontal-s ^net-name <nn> ^min <px> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p4 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^com <max>) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side bottom) + - (horizontal-s ^net-name <nn> ^min <= <px> ^max >= <px> ^id <> <id>) + (pin ^net-name <> <nn> ^pin-x <max> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x <px> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { < <max> > <px> }) + (pin ^net-name <nn> ^pin-x < <px> ^pin-channel-side bottom) + --> + (modify <h> ^max <px>) + (make horizontal-s ^net-name <nn> ^min <px> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p5 + (context ^present reconnect) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <min1> ^max <min> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side top) + - (pin ^pin-x <max> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <max> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^max <max>) +) + +(p p6 + (context ^present reconnect) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <max1> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side bottom) + - (pin ^pin-x <min> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <min> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^min <min>) +) + +(p p7 + (context ^present reconnect) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <min1> ^max <min> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side top) + - (pin ^pin-x <max> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <max> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^max <max>) +) + +(p p8 + (context ^present reconnect) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <max1> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side bottom) + - (pin ^pin-x <min> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <min> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^min <min>) +) + +(p p9 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> } ^max { <max1> <= <max> } ^com <> <com>) + { <v> (vertical-s ^net-name <nn> ^com { <com1> >= <min1> <= <max1> }) } + (pin ^net-name <> <nn> ^pin-x <com1>) + (congestion ^direction col ^coordinate { <px> >= <min1> <= <max1> }) + - (pin ^net-name <> <nn> ^pin-x <px>) + - (vertical-s ^com <px>) + --> + (modify <v> ^com <px>) +) + +(p p10 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> <= <max> } ^max { <max1> >= <max> } ^com <> <com>) + { <v> (vertical-s ^net-name <nn> ^com { <com1> >= <min1> <= <max> }) } + (pin ^net-name <> <nn> ^pin-x <com1>) + (congestion ^direction col ^coordinate { <px> >= <min1> <= <max> }) + - (pin ^net-name <> <nn> ^pin-x <px>) + - (vertical-s ^com <px>) + --> + (modify <v> ^com <px>) +) + +(p p11 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom> ^id <id>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> } ^max { <max1> <= <max> } ^com <> <hcom>) + - (vertical-s ^net-name <nn> ^com { >= <min1> <= <max1> }) + { <v> (vertical-s ^net-name <nn> ^com { <vcom> < <min1> }) } + - (horizontal-s ^net-name <nn> ^min <= <vcom> ^max >= <vcom> ^id <> <id>) + --> + (modify <v> ^com <min1>) +) + +(p p12 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom> ^id <id>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> } ^max { <max1> <= <max> } ^com <> <hcom>) + - (vertical-s ^net-name <nn> ^com { >= <min1> <= <max1> }) + { <v> (vertical-s ^net-name <nn> ^com { <vcom> > <max1> }) } + - (horizontal-s ^net-name <nn> ^min <= <vcom> ^max >= <vcom> ^id <> <id>) + --> + (modify <v> ^com <max1>) +) + +(p p13 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom> ^id <id>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> <= <max> } ^max { <max1> >= <max> } ^com <> <hcom>) + - (vertical-s ^net-name <nn> ^com { >= <min1> <= <max> }) + { <v> (vertical-s ^net-name <nn> ^com { <vcom> < <min1> }) } + - (horizontal-s ^net-name <nn> ^min <= <vcom> ^max >= <vcom> ^id <> <id>) + --> + (modify <v> ^com <min1>) +) + +(p p14 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom> ^id <id>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> <= <max> } ^max { <max1> >= <max> } ^com <> <hcom>) + - (vertical-s ^net-name <nn> ^com { >= <min1> <= <max> }) + { <v> (vertical-s ^net-name <nn> ^com { <vcom> > <max> }) } + - (horizontal-s ^net-name <nn> ^min <= <vcom> ^max >= <vcom> ^id <> <id>) + --> + (modify <v> ^com <max>) +) + +(p p15 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min1> ^max <max1> ^id <id1>) + { <h> (horizontal-s ^net-name <nn> ^min <max1> ^max <max2> ^com <com> ^id <id2>) } + (horizontal-s ^net-name <nn> ^min <max2> ^max <max3> ^id <id3>) + - (horizontal-s ^net-name <nn> ^id { <> <id1> <> <id2> <> <id3> }) + (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com <max1>) + (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com <max2>) + --> + (modify <h> ^min <min1> ^max <max3>) +) + +(p p16 + (context ^present reconnect) + (vertical-s ^net-name <nn> ^min <min1> ^max <max1> ^id <id1>) + { <h> (vertical-s ^net-name <nn> ^min <max1> ^max <max2> ^com <com> ^id <id2>) } + (vertical-s ^net-name <nn> ^min <max2> ^max <max3> ^id <id3>) + - (vertical-s ^net-name <nn> ^id { <> <id1> <> <id2> <> <id3> }) + (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com <max1>) + (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com <max2>) + --> + (modify <h> ^min <min1> ^max <max3>) +) + +(p p17 + (context ^present separate) + { <v> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (horizontal-s ^net-name <nn> ^min <hmin> ^max <com> ^com <max>) + (pin ^net-name <nn> ^pin-y { <py> > <min> < <max> } ^pin-channel-side right) + - (pin ^net-name <nn> ^pin-x > <com> ^pin-y { > <py> <= <max> }) + - (pin ^net-name <nn> ^pin-x <com> ^pin-channel-side top) + - (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <py> < <max> }) + - (horizontal-s ^net-name <nn> ^min <com> ^max <hmax> ^com <max>) + --> + (modify <v> ^max <py>) + (make vertical-s ^net-name <nn> ^min <py> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p18 + (context ^present separate) + { <v> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (horizontal-s ^net-name <nn> ^min <com> ^max <hmax> ^com <max>) + (pin ^net-name <nn> ^pin-y { <py> > <min> < <max> } ^pin-channel-side left) + - (pin ^net-name <nn> ^pin-x < <com> ^pin-y { > <py> <= <max> }) + - (pin ^net-name <nn> ^pin-x <com> ^pin-channel-side top) + - (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <py> < <max> }) + - (horizontal-s ^net-name <nn> ^min <hmin> ^max <com> ^com <max>) + --> + (modify <v> ^max <py>) + (make vertical-s ^net-name <nn> ^min <py> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p19 + (context ^present separate) + { <v> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (horizontal-s ^net-name <nn> ^min <hmin> ^max <com> ^com <min>) + (pin ^net-name <nn> ^pin-y { <py> > <min> < <max> } ^pin-channel-side right) + - (pin ^net-name <nn> ^pin-x > <com> ^pin-y { < <py> >= <min> }) + - (pin ^net-name <nn> ^pin-x <com> ^pin-channel-side bottom) + - (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <min> < <py> }) + - (horizontal-s ^net-name <nn> ^min <com> ^max <hmax> ^com <min>) + --> + (modify <v> ^min <py>) + (make vertical-s ^net-name <nn> ^min <min> ^max <py> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p20 + (context ^present separate) + { <v> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (horizontal-s ^net-name <nn> ^min <com> ^max <hmax> ^com <min>) + (pin ^net-name <nn> ^pin-y { <py> > <min> < <max> } ^pin-channel-side left) + - (pin ^net-name <nn> ^pin-x < <com> ^pin-y { < <py> >= <min> }) + - (pin ^net-name <nn> ^pin-x <com> ^pin-channel-side bottom) + - (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <min> < <py> }) + - (horizontal-s ^net-name <nn> ^min <hmin> ^max <com> ^com <min>) + --> + (modify <v> ^min <py>) + (make vertical-s ^net-name <nn> ^min <min> ^max <py> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p21 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^min <vmin> ^max <com> ^com <min>) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { < <px> >= <min> } ^pin-y > <com>) + - (pin ^net-name <nn> ^pin-y <com> ^pin-channel-side left) + - (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <min> < <px> }) + - (vertical-s ^net-name <nn> ^min <com> ^max <vmax> ^com <min>) + --> + (modify <h> ^min <px>) + (make horizontal-s ^net-name <nn> ^min <min> ^max <px> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p22 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^min <com> ^max <vmax> ^com <min>) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { < <px> >= <min> } ^pin-y < <com>) + - (pin ^net-name <nn> ^pin-y <com> ^pin-channel-side left) + - (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <min> < <px> }) + - (vertical-s ^net-name <nn> ^min <vmin> ^max <com> ^com <min>) + --> + (modify <h> ^min <px>) + (make horizontal-s ^net-name <nn> ^min <min> ^max <px> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p23 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^min <vmin> ^max <com> ^com <max>) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { > <px> <= <max> } ^pin-y > <com>) + - (pin ^net-name <nn> ^pin-y <com> ^pin-channel-side right) + - (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <px> < <max> }) + - (vertical-s ^net-name <nn> ^min <com> ^max <vmax> ^com <max>) + --> + (modify <h> ^max <px>) + (make horizontal-s ^net-name <nn> ^min <px> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p24 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^min <com> ^max <vmax> ^com <max>) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { > <px> <= <max> } ^pin-y < <com>) + - (pin ^net-name <nn> ^pin-y <com> ^pin-channel-side right) + - (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <px> < <max> }) + - (vertical-s ^net-name <nn> ^min <vmin> ^max <com> ^com <max>) + --> + (modify <h> ^max <px>) + (make horizontal-s ^net-name <nn> ^min <px> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p604 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x { <vcom> >= <min> <= <max> } ^pin-channel-side top) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1>) + - (horizontal-s ^net-name <bnn> ^min <= <vcom> ^max >= <vcom> ^id <> <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side bottom) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type vertical) +) + +(p p605 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x { <vcom> >= <min> <= <max> } ^pin-channel-side bottom) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1>) + - (horizontal-s ^net-name <bnn> ^min <= <vcom> ^max >= <vcom> ^id <> <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side top) + - (constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn>) + --> + (make constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn> ^seg-id-1 <id1> ^seg-id-2 <id> ^constraint-type vertical) +) + +(p p606 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x { <vcom> >= <min> <= <max> } ^pin-channel-side top) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1> ^com 1) + (horizontal-s ^net-name <bnn> ^min <= <vcom> ^max >= <vcom> ^id <> <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side bottom) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type vertical) +) + +(p p607 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x { <vcom> >= <min> <= <max> } ^pin-channel-side bottom) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1> ^com <> 1) + (horizontal-s ^net-name <bnn> ^min <= <vcom> ^max >= <vcom> ^id <> <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side top) + - (constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn>) + --> + (make constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn> ^seg-id-1 <id1> ^seg-id-2 <id> ^constraint-type vertical) +) + +(p p608 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference <> 0) + (vertical-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <com> ^id <id1>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x <vcom> ^pin-channel-side top) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side bottom) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type vertical) +) + +(p p609 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference <> 0) + (vertical-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <com> ^id <id1>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x <vcom> ^pin-channel-side bottom) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side top) + - (constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn>) + --> + (make constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn> ^seg-id-1 <id1> ^seg-id-2 <id> ^constraint-type vertical) +) + +(p p610 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com 1 ^id <id>) + (vertical-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <lr> ^id <id1>) + (last-row <lr>) + (vertical-s ^net-name <bnn> ^com <vcom>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x <vcom> ^pin-channel-side top) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side bottom) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type vertical) +) + +(p p611 + (context ^present form-verti) + (vertical-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-y { <vcom> >= <min> <= <max> } ^pin-channel-side right) + (vertical-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-y <vcom> ^pin-channel-side left) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type horizontal) +) + +(p p612 + (context ^present form-verti) + (vertical-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-y { <vcom> >= <min> <= <max> } ^pin-channel-side left) + (vertical-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-y <vcom> ^pin-channel-side right) + - (constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn>) + --> + (make constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn> ^seg-id-1 <id1> ^seg-id-2 <id> ^constraint-type horizontal) +) + +(p p613 + (context ^present form-verti) + (vertical-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference <> 0) + (horizontal-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (vertical-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <com> ^id <id1>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-y <vcom> ^pin-channel-side right) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-y <vcom> ^pin-channel-side left) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type horizontal) +) + +(p p614 + (context ^present form-verti) + (vertical-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference <> 0) + (horizontal-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (vertical-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <com> ^id <id1>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-y <vcom> ^pin-channel-side left) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-y <vcom> ^pin-channel-side right) + - (constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn>) + --> + (make constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn> ^seg-id-1 <id1> ^seg-id-2 <id> ^constraint-type horizontal) +) + +(p p615 + (context ^present form-verti) + (vertical-s ^net-name <tnn> ^min <min> ^max <max> ^com 1 ^id <id>) + (horizontal-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (vertical-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <lc> ^id <id1>) + (last-col <lc>) + (horizontal-s ^net-name <bnn> ^com <vcom>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-y <vcom> ^pin-channel-side right) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-y <vcom> ^pin-channel-side left) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type horizontal) +) + +(p p616 + (context ^present form-verti) + (constraint ^constraint-type vertical ^net-name-1 <tnn> ^net-name-2 <bnn> ^seg-id-1 <tid> ^seg-id-2 <bid>) + (constraint ^constraint-type vertical ^net-name-1 <nn1> ^net-name-2 <tnn> ^seg-id-1 <id1> ^seg-id-2 <tid2>) + - (vertical-cycle <tnn> <tid> <tid2>) + --> + (make vertical-cycle <tnn> <tid> <tid2>) +) + +(p p617 + (context ^present form-verti) + (constraint ^constraint-type horizontal ^net-name-1 <tnn> ^net-name-2 <bnn> ^seg-id-1 <tid> ^seg-id-2 <bid>) + (constraint ^constraint-type horizontal ^net-name-1 <nn1> ^net-name-2 <tnn> ^seg-id-1 <id1> ^seg-id-2 <tid2>) + - (horizontal-cycle <tnn> <tid> <tid2>) + --> + (make horizontal-cycle <tnn> <tid> <tid2>) +) + +(p p618 + (context ^present remove-cycle) + { <h> (horizontal-cycle <nn>) } + - (constraint ^constraint-type horizontal ^net-name-1 <nn>) + - (constraint ^constraint-type horizontal ^net-name-2 <nn>) + --> + (remove <h>) +) + +(p p619 + (context ^present remove-cycle) + { <h> (horizontal-cycle <nn>) } + - (constraint ^constraint-type horizontal ^net-name-2 <nn>) + --> + (remove <h>) +) + +(p p620 + (context ^present remove-cycle) + { <h> (horizontal-cycle <nn>) } + - (constraint ^constraint-type horizontal ^net-name-1 <nn>) + --> + (remove <h>) +) + +(p p621 + (context ^present remove-cycle) + { <h> (vertical-cycle <nn>) } + - (constraint ^constraint-type vertical ^net-name-1 <nn>) + - (constraint ^constraint-type vertical ^net-name-2 <nn>) + --> + (remove <h>) +) + +(p p622 + (context ^present remove-cycle) + { <h> (vertical-cycle <nn>) } + - (constraint ^constraint-type vertical ^net-name-2 <nn>) + --> + (remove <h>) +) + +(p p623 + (context ^present remove-cycle) + { <h> (vertical-cycle <nn>) } + - (constraint ^constraint-type vertical ^net-name-1 <nn>) + --> + (remove <h>) +) + +(p p624 + { <c> (context ^present remove-cycle) } + --> + (remove <c>) +) + +(p p625 + (context ^present remove-cycle) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <min1> ^max <min> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side top) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <max>) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <max> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^max <max>) +) + +(p p626 + (context ^present remove-cycle) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <max1> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side bottom) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <min>) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <min> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^min <min>) +) + +(p p627 + (context ^present remove-cycle) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <min1> ^max <min> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side top) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <max>) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <max> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^max <max>) +) + +(p p628 + (context ^present remove-cycle) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <max1> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side bottom) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <min>) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <min> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^min <min>) +) + +(p p629 + (context ^present remove-cycle) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^com 1) + (ff ^net-name <nn> ^grid-x { <gx> >= <hmin> <= <hmax> } ^grid-y <gy> ^came-from south) + - (ff ^net-name <nn> ^grid-x <> <gx> ^grid-y < <gy>) + - (vertical-s ^net-name <nn> ^min 1 ^max > <gy> ^com <gx>) + --> + (make vertical-s ^net-name <nn> ^min 1 ^max (compute <gy> + 1) ^com <gx> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) +) + +(p p630 + (context ^present remove-cycle) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^com 1) + (ff ^net-name <nn> ^grid-x { <gx> >= <hmin> <= <hmax> } ^grid-y <gy> ^came-from south) + - (ff ^net-name <nn> ^grid-x <> <gx> ^grid-y <= <gy>) + { <v> (vertical-s ^net-name <nn> ^min 1 ^max <= <gy> ^com <gx>) } + --> + (modify <v> ^max (compute <gy> + 1)) +) + +(p p631 + (context ^present remove-cycle) + (last-row <lr>) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^com <lr>) + (ff ^net-name <nn> ^grid-x { <gx> >= <hmin> <= <hmax> } ^grid-y <gy> ^came-from north) + - (ff ^net-name <nn> ^grid-x <> <gx> ^grid-y > <gy>) + - (vertical-s ^net-name <nn> ^min < <gy> ^max <lr> ^com <gx>) + --> + (make vertical-s ^net-name <nn> ^min (compute <gy> - 1) ^max <lr> ^com <gx> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) +) + +(p p632 + (context ^present remove-cycle) + (last-row <lr>) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^com <lr>) + (ff ^net-name <nn> ^grid-x { <gx> >= <hmin> <= <hmax> } ^grid-y <gy> ^came-from north) + - (ff ^net-name <nn> ^grid-x <> <gx> ^grid-y >= <gy>) + { <v> (vertical-s ^net-name <nn> ^min >= <gy> ^max <lr> ^com <gx>) } + --> + (modify <v> ^min (compute <gy> - 1)) +) + +(p p633 + (context ^present remove-cycle) + (vertical-s ^net-name <nn> ^min <vmin> ^max <vmax> ^com 1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy> >= <vmin> <= <vmax> } ^came-from west) + - (ff ^net-name <nn> ^grid-x < <gx> ^grid-y <> <gy>) + - (horizontal-s ^net-name <nn> ^min 1 ^max > <gx> ^com <gy>) + --> + (make horizontal-s ^net-name <nn> ^min 1 ^max (compute <gx> + 1) ^com <gy> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) +) + +(p p634 + (context ^present remove-cycle) + (vertical-s ^net-name <nn> ^min <vmin> ^max <vmax> ^com 1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy> >= <vmin> <= <vmax> } ^came-from west) + - (ff ^net-name <nn> ^grid-x <= <gx> ^grid-y <> <gy>) + { <h> (horizontal-s ^net-name <nn> ^min 1 ^max <= <gx> ^com <gy>) } + --> + (modify <h> ^max (compute <gx> + 1)) +) + +(p p635 + (context ^present remove-cycle) + (last-col <lc>) + (vertical-s ^net-name <nn> ^min <vmin> ^max <vmax> ^com <lc>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy> >= <vmin> <= <vmax> } ^came-from east) + - (ff ^net-name <nn> ^grid-x > <gx> ^grid-y <> <gy>) + - (horizontal-s ^net-name <nn> ^min < <gx> ^max <lc> ^com <gy>) + --> + (make horizontal-s ^net-name <nn> ^min (compute <gx> - 1) ^max <lc> ^com <gy> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) +) + +(p p636 + (context ^present remove-cycle) + (last-col <lc>) + (vertical-s ^net-name <nn> ^min <vmin> ^max <vmax> ^com <lc>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy> >= <vmin> <= <vmax> } ^came-from east) + - (ff ^net-name <nn> ^grid-x >= <gx> ^grid-y <> <gy>) + { <h> (horizontal-s ^net-name <nn> ^min >= <gx> ^max <lc> ^com <gy>) } + --> + (modify <h> ^min (compute <gx> - 1)) +) + +(p p637 + (context ^present remove-cycle) + (last-row <lr>) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^sum 2 ^difference 0) + { <v> (vertical-s ^net-name <nn> ^min 1 ^max { <lr> <> 2 } ^com { <vcom> >= <hmin> <= <hmax> }) } + (pin ^net-name <nn> ^pin-x <vcom> ^pin-channel-side top) + (ff ^net-name <> <nn> ^grid-x <vcom> ^came-from south) + --> + (modify <v> ^min (compute <lr> - 1)) +) + +(p p638 + (context ^present remove-cycle) + (last-row <lr>) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^sum 2 ^difference 0) + { <v> (vertical-s ^net-name <nn> ^min 1 ^max { <lr> <> 2 } ^com { <vcom> >= <hmin> <= <hmax> }) } + (pin ^net-name <nn> ^pin-x <vcom> ^pin-channel-side bottom) + (ff ^net-name <> <nn> ^grid-x <vcom> ^came-from north) + --> + (modify <v> ^max 2) +) + +(p p639 + (context ^present remove-cycle) + (last-col <lc>) + (vertical-s ^net-name <nn> ^min <hmin> ^max <hmax> ^sum 2 ^difference 0) + { <v> (horizontal-s ^net-name <nn> ^min 1 ^max { <lc> <> 2 } ^com { <vcom> >= <hmin> <= <hmax> }) } + (pin ^net-name <nn> ^pin-x <vcom> ^pin-channel-side right) + (ff ^net-name <> <nn> ^grid-x <vcom> ^came-from west) + --> + (modify <v> ^min (compute <lc> - 1)) +) + +(p p640 + (context ^present remove-cycle) + (last-col <lc>) + (vertical-s ^net-name <nn> ^min <hmin> ^max <hmax> ^sum 2 ^difference 0) + { <v> (horizontal-s ^net-name <nn> ^min 1 ^max { <lc> <> 2 } ^com { <vcom> >= <hmin> <= <hmax> }) } + (pin ^net-name <nn> ^pin-x <vcom> ^pin-channel-side left) + (ff ^net-name <> <nn> ^grid-x <vcom> ^came-from east) + --> + (modify <v> ^max 2) +) + +(p p472 + (context ^present partial-route) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) } + { <vs> (vertical-s ^net-name <nn> ^min <gy1> ^max <gy> ^com <gx>) } + { <ff2> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1> ^came-from south) } + { <v> (vertical ^net-name nil ^min <gy1> ^max <gy> ^com <gx> ^layer <lay>) } + --> + (modify <v> ^net-name <nn> ^pin-name <pn>) + (remove <ff1> <ff2> <vs>) +) + +(p p473 + (context ^present partial-route) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from east) } + { <vs> (horizontal-s ^net-name <nn> ^min <gx1> ^max <gx> ^com <gy>) } + { <ff2> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn1> ^came-from west) } + { <v> (horizontal ^net-name nil ^min <gx1> ^max <gx> ^com <gy> ^layer <lay>) } + --> + (modify <v> ^net-name <nn> ^pin-name <pn>) + (remove <ff1> <ff2> <vs>) +) + +(p p474 + (context ^present partial-route) + { <v1> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <vcom>) } + { <h> (horizontal-s ^net-name <nn> ^min <vcom> ^max <hmax> ^com <min> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <vmin> ^max <min> ^com <hmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmin> ^came-from east) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <max> ^came-from north) + --> + (remove <v2>) + (modify <h> ^com <vmin>) + (modify <v1> ^min <vmin>) +) + +(p p475 + (context ^present partial-route) + { <h> (horizontal-s ^net-name <nn> ^min <vcom> ^max <hmax> ^com <min> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <vmin> ^max <min> ^com <hmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmin> ^came-from east) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <min> ^came-from north) + --> + (modify <v2> ^com <vcom>) + (modify <h> ^com <vmin>) +) + +(p p476 + (context ^present partial-route) + { <v1> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <vcom>) } + { <h> (horizontal-s ^net-name <nn> ^min <hmin> ^max <vcom> ^com <min> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <vmin> ^max <min> ^com <hmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmin> ^came-from west) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <max> ^came-from north) + --> + (remove <v2>) + (modify <h> ^com <vmin>) + (modify <v1> ^min <vmin>) +) + +(p p477 + (context ^present partial-route) + { <h> (horizontal-s ^net-name <nn> ^min <hmin> ^max <vcom> ^com <min> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <vmin> ^max <min> ^com <hmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmin> ^came-from west) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <min> ^came-from north) + --> + (modify <v2> ^com <vcom>) + (modify <h> ^com <vmin>) +) + +(p p478 + (context ^present partial-route) + { <v1> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <vcom>) } + { <h> (horizontal-s ^net-name <nn> ^min <vcom> ^max <hmax> ^com <max> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <max> ^max <vmax> ^com <hmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmax> ^came-from east) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <min> ^came-from south) + --> + (remove <v2>) + (modify <h> ^com <vmax>) + (modify <v1> ^max <vmax>) +) + +(p p479 + (context ^present partial-route) + { <h> (horizontal-s ^net-name <nn> ^min <vcom> ^max <hmax> ^com <max> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <max> ^max <vmax> ^com <hmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmax> ^came-from east) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <max> ^came-from south) + --> + (modify <v2> ^com <vcom>) + (modify <h> ^com <vmax>) +) + +(p p480 + (context ^present partial-route) + { <v1> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <vcom>) } + { <h> (horizontal-s ^net-name <nn> ^min <hmin> ^max <vcom> ^com <max> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <max> ^max <vmax> ^com <hmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmax> ^came-from west) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <min> ^came-from south) + --> + (remove <v2>) + (modify <h> ^com <vmax>) + (modify <v1> ^max <vmax>) +) + +(p p481 + (context ^present partial-route) + { <h> (horizontal-s ^net-name <nn> ^min <hmin> ^max <vcom> ^com <max> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <max> ^max <vmax> ^com <hmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmax> ^came-from west) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <max> ^came-from south) + --> + (modify <v2> ^com <vcom>) + (modify <h> ^com <vmax>) +) + +(p p482 + (context ^present partial-route) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom>) } + { <v> (vertical-s ^net-name <nn> ^min <hcom> ^max <vmax> ^com <min> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <hmin> ^max <min> ^com <vmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmax> ^came-from north) + (ff ^net-name <nn> ^grid-x <max> ^grid-y <hcom> ^came-from east) + --> + (remove <h2>) + (modify <v> ^com <hmin>) + (modify <h1> ^min <hmin>) +) + +(p p483 + (context ^present partial-route) + { <v> (vertical-s ^net-name <nn> ^min <hcom> ^max <vmax> ^com <min> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <hmin> ^max <min> ^com <vmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmax> ^came-from north) + (ff ^net-name <nn> ^grid-x <min> ^grid-y <hcom> ^came-from east) + --> + (modify <h2> ^com <hcom>) + (modify <v> ^com <hmin>) +) + +(p p484 + (context ^present partial-route) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom>) } + { <v> (vertical-s ^net-name <nn> ^min <hcom> ^max <vmax> ^com <max> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <hmax> ^com <vmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmax> ^came-from north) + (ff ^net-name <nn> ^grid-x <min> ^grid-y <hcom> ^came-from west) + --> + (remove <h2>) + (modify <v> ^com <hmax>) + (modify <h1> ^max <hmax>) +) + +(p p485 + (context ^present partial-route) + { <v> (vertical-s ^net-name <nn> ^min <hcom> ^max <vmax> ^com <max> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <hmax> ^com <vmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmax> ^came-from north) + (ff ^net-name <nn> ^grid-x <max> ^grid-y <hcom> ^came-from west) + --> + (modify <h2> ^com <hcom>) + (modify <v> ^com <hmax>) +) + +(p p486 + (context ^present partial-route) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom>) } + { <v> (vertical-s ^net-name <nn> ^min <vmin> ^max <hcom> ^com <min> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <hmin> ^max <min> ^com <vmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmin> ^came-from south) + (ff ^net-name <nn> ^grid-x <max> ^grid-y <hcom> ^came-from east) + --> + (remove <h2>) + (modify <v> ^com <hmin>) + (modify <h1> ^min <hmin>) +) + +(p p487 + (context ^present partial-route) + { <v> (vertical-s ^net-name <nn> ^min <vmin> ^max <hcom> ^com <min> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <hmin> ^max <min> ^com <vmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmin> ^came-from south) + (ff ^net-name <nn> ^grid-x <min> ^grid-y <hcom> ^came-from east) + --> + (modify <h2> ^com <hcom>) + (modify <v> ^com <hmin>) +) + +(p p488 + (context ^present partial-route) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom>) } + { <v> (vertical-s ^net-name <nn> ^min <vmin> ^max <hcom> ^com <max> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <hmax> ^com <vmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmin> ^came-from south) + (ff ^net-name <nn> ^grid-x <min> ^grid-y <hcom> ^came-from west) + --> + (remove <h2>) + (modify <v> ^com <hmax>) + (modify <h1> ^max <hmax>) +) + +(p p489 + (context ^present partial-route) + { <v> (vertical-s ^net-name <nn> ^min <vmin> ^max <hcom> ^com <max> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <hmax> ^com <vmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmin> ^came-from south) + (ff ^net-name <nn> ^grid-x <max> ^grid-y <hcom> ^came-from west) + --> + (modify <h2> ^com <hcom>) + (modify <v> ^com <hmax>) +) + +(p p186 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> < 0 }) + - (horizontal-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from south) } + - (ff ^net-name <nn> ^grid-x <garb1> ^grid-y < <gy1>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y <gy1>) + - (horizontal ^net-name nil ^min < <gx2> ^max > <gx1> ^com <gy1>) + - (horizontal ^net-name nil ^min <gx2> ^max > <gx1> ^com <gy1> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx2> ^max <gx1> ^com <gy1> ^max-net nil) + { <v> (vertical ^net-name nil ^max { <max> > <gy1> } ^min { < <max> <= <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> bottom) + - (vertical-cycle <nn>) + --> + (modify <v> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy1> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p187 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> < 0 }) + - (horizontal-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from south) } + - (ff ^net-name <nn> ^grid-x <garb1> ^grid-y < <gy1>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y <gy1>) + - (horizontal ^net-name nil ^min < <gx1> ^max > <gx2> ^com <gy1>) + - (horizontal ^net-name nil ^min <gx1> ^max > <gx2> ^com <gy1> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx1> ^max <gx2> ^com <gy1> ^max-net nil) + { <v> (vertical ^net-name nil ^max { <max> > <gy1> } ^min { < <max> <= <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> bottom) + - (vertical-cycle <nn>) + --> + (modify <v> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy1> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p188 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> < 0 }) + - (horizontal-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from south) } + (vertical-s ^net-name <nn> ^min <= <gy1> ^max > <gy1> ^com <gx1>) + - (ff ^net-name <nn> ^grid-x <> <gx1> ^grid-y <= <gy1>) + { <v> (vertical ^net-name nil ^max { <max> > <gy1> } ^min { < <max> <= <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy1>) + - (vertical-s ^net-name <> <nn> ^min <= <gy2> ^max >= <gy2> ^com <gx1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> bottom) + - (vertical-cycle <nn>) + --> + (make extended-ff <nn> bottom) + (modify <v> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy1> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p189 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> > 0 }) + - (horizontal-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from north) } + - (ff ^net-name <nn> ^grid-x <garb1> ^grid-y > <gy1>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y <gy1>) + - (horizontal ^net-name nil ^min < <gx2> ^max > <gx1> ^com <gy1>) + - (horizontal ^net-name nil ^min <gx2> ^max > <gx1> ^com <gy1> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx2> ^max <gx1> ^com <gy1> ^max-net nil) + { <v> (vertical ^net-name nil ^max { <max> >= <gy1> } ^min { < <max> < <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy1> ^como <gy2>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> top) + - (vertical-cycle <nn>) + --> + (modify <v> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy1> ^min <gy2> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p190 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> > 0 }) + - (horizontal-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from north) } + - (ff ^net-name <nn> ^grid-x <garb1> ^grid-y > <gy1>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y <gy1>) + - (horizontal ^net-name nil ^min < <gx1> ^max > <gx2> ^com <gy1>) + - (horizontal ^net-name nil ^min <gx1> ^max > <gx2> ^com <gy1> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx1> ^max <gx2> ^com <gy1> ^max-net nil) + { <v> (vertical ^net-name nil ^max { <max> >= <gy1> } ^min { < <max> < <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy1> ^como <gy2>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> top) + - (vertical-cycle <nn>) + --> + (modify <v> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy1> ^min <gy2> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p191 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> > 0 }) + - (horizontal-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from north) } + (vertical-s ^net-name <nn> ^min < <gy1> ^max >= <gy1> ^com <gx1>) + - (ff ^net-name <nn> ^grid-x <> <gx1> ^grid-y >= <gy1>) + { <v> (vertical ^net-name nil ^max { <max> >= <gy1> } ^min { < <max> < <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy1> ^como <gy2>) + - (vertical-s ^net-name <> <nn> ^min <= <gy2> ^max >= <gy2> ^com <gx1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> top) + - (vertical-cycle <nn>) + --> + (make extended-ff <nn> top) + (modify <v> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy1> ^min <gy2> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p192 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (horizontal-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <max> ^grid-y <gy> ^grid-layer <lay> ^came-from south ^pin-name <pn>) } + - (horizontal ^net-name nil ^min < <max> ^max >= <max> ^com <gy>) + { <v> (vertical ^net-name nil ^max { <vmax> > <gy> } ^min { < <vmax> <= <gy> } ^com <max> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <max> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <max> ^max >= <max> ^com <gy2> ^layer <lay>) + - (vertical-cycle <nn>) + (horizontal ^net-name nil ^min < <max> ^max >= <max> ^com > <gy>) + --> + (modify <v> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy> ^layer <lay> ^com <max> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p193 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (horizontal-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <min> ^grid-y <gy> ^grid-layer <lay> ^came-from south ^pin-name <pn>) } + - (horizontal ^net-name nil ^min <= <min> ^max > <min> ^com <gy>) + { <v> (vertical ^net-name nil ^max { <vmax> > <gy> } ^min { < <vmax> <= <gy> } ^com <min> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <min> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <min> ^max >= <min> ^com <gy2> ^layer <lay>) + - (vertical-cycle <nn>) + (horizontal ^net-name nil ^min <= <min> ^max > <min> ^com > <gy>) + --> + (modify <v> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy> ^layer <lay> ^com <min> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p194 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (horizontal-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <max> ^grid-y <gy> ^grid-layer <lay> ^came-from north ^pin-name <pn>) } + - (horizontal ^net-name nil ^min < <max> ^max >= <max> ^com <gy>) + { <v> (vertical ^net-name nil ^max { <vmax> >= <gy> } ^min { < <vmax> < <gy> } ^com <max> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy> ^como <gy2>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <max> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <max> ^max >= <max> ^com <gy2> ^layer <lay>) + - (vertical-cycle <nn>) + (horizontal ^net-name nil ^min < <max> ^max >= <max> ^com < <gy>) + --> + (modify <v> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <gy2> ^layer <lay> ^com <max> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p195 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (horizontal-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <min> ^grid-y <gy> ^grid-layer <lay> ^came-from north ^pin-name <pn>) } + - (horizontal ^net-name nil ^min <= <min> ^max > <min> ^com <gy>) + { <v> (vertical ^net-name nil ^max { <vmax> >= <gy> } ^min { < <vmax> < <gy> } ^com <min> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy> ^como <gy2>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <min> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <min> ^max >= <min> ^com <gy2> ^layer <lay>) + - (vertical-cycle <nn>) + (horizontal ^net-name nil ^min <= <min> ^max > <min> ^com < <gy>) + --> + (modify <v> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <gy2> ^layer <lay> ^com <min> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p196 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> < 0 }) + - (vertical-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from west) } + - (ff ^net-name <nn> ^grid-x < <gx1> ^grid-y <garb1>) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y { <gy2> < <gy1> }) + - (vertical ^net-name nil ^min < <gy2> ^max > <gy1> ^com <gx1>) + - (vertical ^net-name nil ^min <gy2> ^max > <gy1> ^com <gx1> ^min-net nil) + - (vertical ^net-name nil ^min < <gy2> ^max <gy1> ^com <gx1> ^max-net nil) + { <v> (horizontal ^net-name nil ^max { <max> > <gx1> } ^min { < <max> <= <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> left) + - (horizontal-cycle <nn>) + --> + (modify <v> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^max <gx2> ^min <gx1> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p197 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> < 0 }) + - (vertical-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from west) } + - (ff ^net-name <nn> ^grid-x < <gx1> ^grid-y <garb1>) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y { <gy2> > <gy1> }) + - (vertical ^net-name nil ^min < <gy1> ^max > <gy2> ^com <gx1>) + - (vertical ^net-name nil ^min <gy1> ^max > <gy2> ^com <gx1> ^min-net nil) + - (vertical ^net-name nil ^min < <gy1> ^max <gy2> ^com <gx1> ^max-net nil) + { <v> (horizontal ^net-name nil ^max { <max> > <gx1> } ^min { < <max> <= <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> left) + - (horizontal-cycle <nn>) + --> + (modify <v> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^max <gx2> ^min <gx1> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p198 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> < 0 }) + - (vertical-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from west) } + (horizontal-s ^net-name <nn> ^min <= <gx1> ^max > <gx1> ^com <gy1>) + - (ff ^net-name <nn> ^grid-x <= <gx1> ^grid-y <> <gy1>) + { <v> (horizontal ^net-name nil ^max { <max> > <gx1> } ^min { < <max> <= <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx1>) + - (horizontal-s ^net-name <> <nn> ^min <= <gx2> ^max >= <gx2> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> left) + - (horizontal-cycle <nn>) + --> + (make extended-ff <nn> left) + (modify <v> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^max <gx2> ^min <gx1> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p199 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> > 0 }) + - (vertical-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from east) } + - (ff ^net-name <nn> ^grid-x > <gx1> ^grid-y <garb1>) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y { <gy2> < <gy1> }) + - (vertical ^net-name nil ^min < <gy2> ^max > <gy1> ^com <gx1>) + - (vertical ^net-name nil ^min <gy2> ^max > <gy1> ^com <gx1> ^min-net nil) + - (vertical ^net-name nil ^min < <gy2> ^max <gy1> ^com <gx1> ^max-net nil) + { <v> (horizontal ^net-name nil ^max { <max> >= <gx1> } ^min { < <max> < <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx1> ^como <gx2>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> right) + - (horizontal-cycle <nn>) + --> + (modify <v> ^max <gx2> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx1> ^min <gx2> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p200 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> > 0 }) + - (vertical-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from east) } + - (ff ^net-name <nn> ^grid-x > <gx1> ^grid-y <gy1>) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y { <gy2> > <gy1> }) + - (vertical ^net-name nil ^min < <gy1> ^max > <gy2> ^com <gx1>) + - (vertical ^net-name nil ^min <gy1> ^max > <gy2> ^com <gx1> ^min-net nil) + - (vertical ^net-name nil ^min < <gy1> ^max <gy2> ^com <gx1> ^max-net nil) + { <v> (horizontal ^net-name nil ^max { <max> >= <gx1> } ^min { < <max> < <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx1> ^como <gx2>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> right) + - (horizontal-cycle <nn>) + --> + (modify <v> ^max <gx2> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx1> ^min <gx2> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p201 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> > 0 }) + - (vertical-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from east) } + (horizontal-s ^net-name <nn> ^min < <gx1> ^max >= <gx1> ^com <gy1>) + - (ff ^net-name <nn> ^grid-x >= <gx1> ^grid-y <> <gy1>) + { <v> (horizontal ^net-name nil ^max { <max> >= <gx1> } ^min { < <max> < <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx1> ^como <gx2>) + - (horizontal-s ^net-name <> <nn> ^min <= <gx2> ^max >= <gx2> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> right) + - (horizontal-cycle <nn>) + --> + (make extended-ff <nn> right) + (modify <v> ^max <gx2> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx1> ^min <gx2> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p202 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (vertical-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <max> ^grid-layer <lay> ^came-from west ^pin-name <pn>) } + - (vertical ^net-name nil ^min < <max> ^max >= <max> ^com <gx>) + { <v> (horizontal ^net-name nil ^max { <vmax> > <gx> } ^min { < <vmax> <= <gx> } ^com <max> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <max> ^layer <lay>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <max> ^max >= <max> ^com <gx2> ^layer <lay>) + - (horizontal-cycle <nn>) + --> + (modify <v> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^max <gx2> ^min <gx> ^layer <lay> ^com <max> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p203 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (vertical-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <min> ^grid-layer <lay> ^came-from west ^pin-name <pn>) } + - (vertical ^net-name nil ^min <= <min> ^max > <min> ^com <gx>) + { <v> (horizontal ^net-name nil ^max { <vmax> > <gx> } ^min { < <vmax> <= <gx> } ^com <min> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <min> ^layer <lay>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <min> ^max >= <min> ^com <gx2> ^layer <lay>) + - (horizontal-cycle <nn>) + --> + (modify <v> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^max <gx2> ^min <gx> ^layer <lay> ^com <min> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p204 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (vertical-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <max> ^grid-layer <lay> ^came-from east ^pin-name <pn>) } + - (vertical ^net-name nil ^min < <max> ^max >= <max> ^com <gx>) + { <v> (horizontal ^net-name nil ^max { <vmax> >= <gx> } ^min { < <vmax> < <gx> } ^com <max> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx> ^como <gx2>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <max> ^layer <lay>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <max> ^max >= <max> ^com <gx2> ^layer <lay>) + - (horizontal-cycle <nn>) + --> + (modify <v> ^max <gx2> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx> ^min <gx2> ^layer <lay> ^com <max> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p205 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (vertical-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <min> ^grid-layer <lay> ^came-from east ^pin-name <pn>) } + - (vertical ^net-name nil ^min <= <min> ^max > <min> ^com <gx>) + { <v> (horizontal ^net-name nil ^max { <vmax> >= <gx> } ^min { < <vmax> < <gx> } ^com <min> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx> ^como <gx2>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <min> ^layer <lay>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <min> ^max >= <min> ^com <gx2> ^layer <lay>) + - (horizontal-cycle <nn>) + --> + (modify <v> ^max <gx2> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx> ^min <gx2> ^layer <lay> ^com <min> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p206 + { <c> (context ^present extend-h-v-s) } + --> + (modify <c> ^present loose-constraint0) +) + +(p p207 + { <c> (context ^present extend-h-v-s) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^came-from west ^pin-name <pn>) } + (horizontal-s ^net-name <nn> ^min <= <gx> ^max { <hmaxs> > <gx> } ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^com <gy>) + (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy> ^com { <vcoms> > <gx> <= <hmaxs> }) + - (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy> ^com { >= <gx> < <vcoms> }) + { <h> (horizontal ^net-name nil ^min <gx> ^max { <hmax> >= <vcoms> } ^com <gy> ^layer <lay>) } + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <vcoms> ^layer <lay>) + --> + (make (substr <h> 1 inf) ^net-name <nn> ^pin-name <pn> ^max <vcoms>) + (modify <h> ^min <vcoms> ^min-net <nn>) + (modify <ff> ^grid-x <vcoms> ^can-chng-layer nil) + (modify <c> ^present propagate-constraint) +) + +(p p208 + { <c> (context ^present extend-h-v-s) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^came-from east ^pin-name <pn>) } + (horizontal-s ^net-name <nn> ^min { <hmins> < <gx> } ^max >= <gx> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^com <gy>) + (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy> ^com { <vcoms> < <gx> >= <hmins> }) + - (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy> ^com { <= <gx> > <vcoms> }) + { <h> (horizontal ^net-name nil ^min { <hmin> <= <vcoms> } ^max <gx> ^com <gy> ^layer <lay>) } + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <vcoms> ^layer <lay>) + --> + (make (substr <h> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <vcoms>) + (modify <h> ^max <vcoms> ^max-net <nn>) + (modify <ff> ^grid-x <vcoms> ^can-chng-layer nil) + (modify <c> ^present propagate-constraint) +) + +(p p209 + { <c> (context ^present extend-h-v-s) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^came-from south ^pin-name <pn>) } + (vertical-s ^net-name <nn> ^min <= <gy> ^max { <vmaxs> > <gy> } ^com <gx>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <gx>) + (horizontal-s ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { <hcoms> > <gy> <= <vmaxs> }) + - (horizontal-s ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { >= <gy> < <hcoms> }) + { <v> (vertical ^net-name nil ^min <gy> ^max { <vmax> >= <hcoms> } ^com <gx> ^layer <lay>) } + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <hcoms> ^layer <lay>) + --> + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^max <hcoms>) + (modify <v> ^min <hcoms> ^min-net <nn>) + (modify <ff> ^grid-y <hcoms> ^can-chng-layer nil) + (modify <c> ^present propagate-constraint) +) + +(p p210 + { <c> (context ^present extend-h-v-s) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^came-from north ^pin-name <pn>) } + (vertical-s ^net-name <nn> ^min { <vmins> < <gy> } ^max >= <gy> ^com <gx>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <gx>) + (horizontal-s ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { <hcoms> < <gy> >= <vmins> }) + - (horizontal-s ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { <= <gy> > <hcoms> }) + { <v> (vertical ^net-name nil ^min { <vmin> <= <hcoms> } ^max <gy> ^com <gx> ^layer <lay>) } + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <hcoms> ^layer <lay>) + --> + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <hcoms>) + (modify <v> ^max <hcoms> ^max-net <nn>) + (modify <ff> ^grid-y <hcoms> ^can-chng-layer nil) + (modify <c> ^present propagate-constraint) +) + +(p p29 + (goal cleanup <c>) + (<c>) + --> + (remove 2) +) + +(p p30 + (goal cleanup <c>) + - (<c>) + --> + (remove 1) +) + +(p p31 + (goal cleanup) + (verti-has-loop) + --> + (remove 2) +) + +(p p83 + (context ^present propagate-constraint) + --> + (remove 1) + (make context ^previous propagate-constraint) + (make context ^present remove-cycle) +) + +(p p84 + (context ^present << propagate-constraint extend-pins move-ff >>) + (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com> ^layer <lay> ^compo <cpo> ^commo <egarb1>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <min2> <= <max1> } ^max { <max2> >= <min1> } ^com <cpo> ^layer <lay> ^compo <garb1> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min { <min3> <= <com> } ^max { <max3> >= <cpo> > <min3> } ^com { <com2> <= <max1> >= <min1> <= <max2> >= <min2> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <mnn> ^max-net <man>) } + --> + (make vertical ^min <min3> ^max <com> ^com <com2> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^max-net <nn1> ^min-net <mnn>) + (make vertical ^min <cpo> ^max <max3> ^com <com2> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^min-net <nn2> ^max-net <man>) + (remove <v1>) +) + +(p p85 + (context ^present << propagate-constraint extend-pins >>) + (ff ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <com> ^layer <lay> ^compo <egarb2> ^commo <gy>) + { <v1> (vertical ^net-name nil ^min { <min3> <= <gy> } ^max { <max3> >= <com> > <min3> } ^com <gx> ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <mnn> ^max-net <man>) } + --> + (make vertical ^min <min3> ^max <gy> ^com <gx> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^max-net <nn1> ^min-net <mnn>) + (make vertical ^min <com> ^max <max3> ^com <gx> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^min-net <nn2> ^max-net <man>) + (remove <v1>) +) + +(p p86 + (context ^present << propagate-constraint extend-pins >>) + (ff ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <com> ^layer <lay> ^compo <gy> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min { <min3> <= <com> } ^max { <max3> >= <gy> > <min3> } ^com <gx> ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <mnn> ^max-net <man>) } + --> + (make vertical ^min <min3> ^max <com> ^com <gx> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^max-net <nn2> ^min-net <mnn>) + (make vertical ^min <gy> ^max <max3> ^com <gx> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^min-net <nn1> ^max-net <man>) + (remove <v1>) +) + +(p p87 + (context ^present propagate-constraint) + (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <garb1> ^max <max1> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min <min2> ^max <gar2> ^com <com> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <min2> > <max1> } ^com <com> ^layer <lay> ^compo <egarb5> ^commo <egarb6>) } + - (vertical ^com { > <max1> < <min2> }) + --> + (remove <h1>) +) + +(p p88 + (context ^present << propagate-constraint extend-pins move-ff >>) + (vertical ^status nil ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com> ^layer <lay> ^compo <cpo> ^commo <egarb1>) + (vertical ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <min2> <= <max1> } ^max { <max2> >= <min1> } ^com <cpo> ^layer <lay> ^compo <garb1> ^compo <egarb2>) + { <h1> (horizontal ^net-name nil ^min { <min3> <= <com> } ^max { <max3> >= <cpo> } ^com { <com2> <= <max1> >= <min1> <= <max2> >= <min2> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <mnn> ^max-net <man>) } + --> + (make horizontal ^min <min3> ^max <com> ^com <com2> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^min-net <mnn> ^max-net <nn1>) + (make horizontal ^min <cpo> ^max <max3> ^com <com2> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^max-net <man> ^min-net <nn2>) + (remove <h1>) +) + +(p p89 + (context ^present propagate-constraint) + (vertical ^status nil ^net-name { <nn1> <> nil } ^min <garb1> ^max <max1> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (vertical ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min <min2> ^max <garb2> ^com <com> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) + - (horizontal ^com { > <max1> < <min2> }) + { <v1> (vertical ^net-name nil ^min <max1> ^max { <min2> > <max1> } ^com <com> ^layer <lay> ^compo <egarb5> ^commo <egarb6>) } + --> + (remove <v1>) +) + +(p p90 + (context ^present propagate-constraint) + (vertical ^status nil ^net-name { <nn1> <> nil } ^min <vmin> ^max <garb1> ^com <vcom> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb2> <= <vcom> } ^max { <garb3> >= <vcom> } ^com <hcom> ^layer <lay> ^compo <vmin> ^commo <garb5>) + { <v1> (vertical ^net-name nil ^min <garb4> ^max { <vmin> > <garb4> } ^com <vcom> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) } + --> + (modify <v1> ^max <hcom> ^max-net <nn2>) +) + +(p p91 + (context ^present propagate-constraint) + (vertical ^status nil ^net-name { <nn1> <> nil } ^min <garb1> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb2> <= <vcom> } ^max { <garb3> >= <vcom> } ^com <hcom> ^layer <lay> ^compo <garb4> ^commo <vmax>) + { <v1> (vertical ^net-name nil ^min <vmax> ^max { <garb5> > <vmax> } ^com <vcom> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) } + --> + (modify <v1> ^min <hcom> ^min-net <nn2>) +) + +(p p92 + (context ^present propagate-constraint) + (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <min> ^max <garb1> ^com <hcom> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (vertical ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb2> <= <hcom> } ^max { <garb3> >= <hcom> } ^com <vcom> ^layer <lay> ^compo <min> ^commo <egarb3>) + { <h1> (horizontal ^net-name nil ^min <garb4> ^max { <min> > <garb4> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + --> + (modify <h1> ^max <vcom> ^max-net <nn2>) +) + +(p p93 + (context ^present propagate-constraint) + (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <garb1> ^max <max> ^com <hcom> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (vertical ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb2> <= <hcom> } ^max { <garb3> >= <hcom> } ^com <vcom> ^layer <lay> ^compo <garb4> ^commo <max>) + { <h1> (horizontal ^net-name nil ^min <max> ^max { <garb4> > <max> } ^com <hcom> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) } + --> + (modify <h1> ^min <vcom> ^min-net <nn2>) +) + +(p p94 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + { <h1> (horizontal ^net-name nil ^min <garb3> ^max { <gx> > <garb3> } ^com <gy> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) } + (vertical ^status nil ^net-name { <nn2> <> <nn> <> nil } ^min { <garb1> <= <gy> } ^max { <garb2> >= <gy> } ^com <vcom> ^layer <lay> ^compo <gx> ^commo <egarb2>) + --> + (modify <h1> ^max <vcom> ^max-net <nn2>) +) + +(p p95 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { <garb4> > <gx> } ^com <gy> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + (vertical ^status nil ^net-name { <nn2> <> <nn> <> nil } ^min { <garb1> <= <gy> } ^max { <garb2> >= <gy> } ^com <vcom> ^layer <lay> ^compo <garb3> ^commo <gx>) + --> + (modify <h1> ^min <vcom> ^min-net <nn2>) +) + +(p p96 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + (horizontal ^status nil ^net-name { <nn2> <> <nn> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <hcom> ^layer <lay> ^compo <gy> ^commo <garb3>) + { <v1> (vertical ^net-name nil ^min <garb4> ^max { <gy> > <garb4> } ^com <gx> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + --> + (modify <v1> ^max <hcom> ^max-net <nn2>) +) + +(p p97 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + (horizontal ^status nil ^net-name { <nn2> <> <nn> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <hcom> ^layer <lay> ^compo <garb3> ^commo <gy>) + { <v1> (vertical ^net-name nil ^min <gy> ^max { <garb4> > <gy> } ^com <gx> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + --> + (modify <v1> ^min <hcom> ^min-net <nn2>) +) + +(p p98 + (context ^present << propagate-constraint extend-pins random1 check-for-routed-net >>) + { <h1> (horizontal ^min <min> ^max <= <min>) } + --> + (remove <h1>) +) + +(p p99 + (context ^present << propagate-constraint extend-pins random1 check-for-routed-net >>) + { <v1> (vertical ^min <min> ^max <= <min>) } + --> + (remove <v1>) +) + +(p p100 + { <h1> (horizontal ^min <min> ^max <= <min>) } + --> + (remove <h1>) +) + +(p p101 + { <v1> (vertical ^min <min> ^max <= <min>) } + --> + (remove <v1>) +) + +(p p102 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <min1> ^max { <max1> > <min1> } ^com <com1> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (vertical ^status nil ^min <= <com1> ^max >= <com1> ^com <min1>) + - (horizontal ^status nil ^min < <min1> ^max >= <min1> ^com <com1>) + (vertical ^status nil ^net-name <garb1> ^min { <vmin> <= <com1> } ^max { >= <com1> > <vmin> } ^com { <com2> > <min1> <= <max1> } ^layer <garb2> ^compo <egarb4> ^commo <egarb5>) + - (vertical ^status nil ^min <= <com1> ^max >= <com1> ^com { < <com2> >= <min1> }) + --> + (modify <h1> ^min <com2> ^min-net nil) +) + +(p p103 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <min1> ^max { <max1> > <min1> } ^com <com1> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (horizontal ^status nil ^min <= <com1> ^max >= <com1> ^com <min1>) + - (vertical ^status nil ^min < <min1> ^max >= <min1> ^com <com1>) + (horizontal ^status nil ^net-name <garb1> ^min { <hmin> <= <com1> } ^max { <garb2> >= <com1> > <hmin> } ^com { <com2> > <min1> <= <max1> } ^layer <garb3> ^compo <egarb4> ^commo <egarb5>) + - (horizontal ^status nil ^min <= <com1> ^max >= <com1> ^com { < <com2> >= <min1> }) + --> + (modify <v1> ^min <com2> ^min-net nil) +) + +(p p104 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <min1> ^max { <max1> > <min1> } ^com <com1> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + - (vertical ^status nil ^min <= <com1> ^max >= <com1> ^com <max1>) + - (horizontal ^status nil ^min <= <max1> ^max > <max1> ^com <com1>) + (vertical ^status nil ^net-name <garb1> ^min { <vmin> <= <com1> } ^max { <garb2> >= <com1> > <vmin> } ^com { <com2> >= <min1> < <max1> } ^layer <egarb1> ^compo <egarb2> ^commo <egarb3>) + - (vertical ^status nil ^min <= <com1> ^max >= <com1> ^com { > <com2> <= <max1> }) + --> + (modify <h1> ^max <com2> ^max-net nil) +) + +(p p105 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <min1> ^max { <max1> > <min1> } ^com <com1> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (horizontal ^status nil ^min <= <com1> ^max >= <com1> ^com <max1>) + - (vertical ^status nil ^min <= <max1> ^max > <max1> ^com <com1>) + (horizontal ^status nil ^net-name <garb1> ^min { <hmin> <= <com1> } ^max { <garb2> >= <com1> > <hmin> } ^com { <com2> >= <min1> < <max1> } ^layer <egarb1> ^compo <egarb4> ^commo <egarb5>) + - (horizontal ^status nil ^min <= <com1> ^max >= <com1> ^com { > <com2> <= <max1> }) + --> + (modify <v1> ^max <com2> ^max-net nil) +) + +(p p106 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <hmin> ^max { <hmax> > <hmin> } ^com <hcom> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) } + - (vertical ^com { > <hmin> < <hmax> }) + - (vertical ^status nil ^min <= <hcom> ^max >= <hcom> ^com <hmax> ^layer <lay>) + - (horizontal ^status nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <lay>) + (vertical ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <hmax> ^layer <> <lay> ^compo <egarb4> ^commo <egarb5>) + (vertical ^net-name { <> <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <hmin> ^layer <> <lay> ^compo <egarb2> ^commo <egarb3>) + --> + (remove <h1>) +) + +(p p107 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <vmin> ^max { <vmax> > <vmin> } ^com <vcom> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (horizontal ^com { > <vmin> < <vmax> }) + - (horizontal ^status nil ^min <= <vcom> ^max >= <vcom> ^com <vmax> ^layer <lay>) + - (vertical ^status nil ^min <vmax> ^max > <vmax> ^com <vcom> ^layer <lay>) + (horizontal ^net-name { <nn1> <> nil } ^min { <garb1> <= <vcom> } ^max { <garb2> >= <vcom> } ^com <vmax> ^layer { <garb3> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + (horizontal ^net-name { <> <nn1> <> nil } ^min { <garb4> <= <vcom> } ^max { <garb5> >= <vcom> } ^com <vmin> ^layer { <garb6> <> <lay> } ^compo <egarb4> ^commo <egarb5>) + --> + (remove <v1>) +) + +(p p108 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <hmin> ^max { <hmax> > <hmin> } ^com <hcom> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) } + - (vertical ^com { > <hmin> < <hmax> }) + - (vertical ^status nil ^min <= <hcom> ^max >= <hcom> ^com <hmin> ^layer <lay>) + - (horizontal ^status nil ^min < <hmin> ^max <hmin> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^min <= <hcom> ^max >= <hcom> ^com <hmax> ^layer <lay>) + - (horizontal ^status nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <lay>) + (vertical ^net-name { <nn1> <> nil } ^min { <garb1> <= <hcom> } ^max { <garb2> >= <hcom> } ^com <hmax> ^layer { <garb3> <> <lay> } ^compo <egarb2> ^commo <egarb3>) + (vertical ^net-name { <garb7> <> <nn1> <> nil } ^min { <gabr4> <= <hcom> } ^max { <garb5> >= <hcom> } ^com <hmin> ^layer { <garb6> <> <lay> } ^compo <egarb4> ^commo <egarb5>) + --> + (remove <h1>) +) + +(p p109 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <vmin> ^max { <vmax> > <vmin> } ^com <vcom> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) } + - (horizontal ^com { > <vmin> < <vmax> }) + - (horizontal ^status nil ^min <= <vcom> ^max >= <vcom> ^com <vmin> ^layer <lay>) + - (vertical ^status nil ^min < <vmin> ^max <vmin> ^com <vcom> ^layer <lay>) + (horizontal ^net-name { <nn1> <> nil } ^min { <garb1> <= <vcom> } ^max { <garb2> >= <vcom> } ^com <vmax> ^layer { <garb3> <> <lay> } ^compo <egarb2> ^commo <egarb3>) + (horizontal ^net-name { <garb7> <> <nn1> <> nil } ^min { <garb4> <= <vcom> } ^max { <garb5> >= <vcom> } ^com <vmin> ^layer { <garb6> <> <lay> } ^compo <egarb4> ^commo <egarb5>) + --> + (remove <v1>) +) + +(p p110 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <max2> > <max1> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + - (vertical ^min <= <hcom> ^max >= <hcom> ^com <max2> ^layer <lay>) + - (horizontal ^min <max2> ^max > <max2> ^com <hcom> ^layer <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com { > <max1> < <max2> }) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com { > <max1> < <max2> } ^max-net nil) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com { > <max1> < <max2> } ^min-net nil) + (horizontal ^net-name { <nn> <> nil } ^min <garb1> ^max <max1> ^com <hcom> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) + (vertical ^net-name { <nn1> <> <nn> <> nil } ^min { <garb4> <= <hcom> } ^max { <garb2> >= <hcom> } ^com <max2> ^layer { <garb3> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + - (vertical ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com { > <max1> < <max2> }) + --> + (modify <h1> ^max (compute <max2> - 1) ^max-net nil) +) + +(p p111 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <max2> > <max1> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + - (vertical ^min <= <hcom> ^max >= <hcom> ^com <max1> ^layer <lay>) + - (horizontal ^min < <max1> ^max <max1> ^com <hcom> ^layer <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com { > <max1> < <max2> }) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com { > <max1> < <max2> } ^max-net nil) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com { > <max1> < <max2> } ^min-net nil) + (horizontal ^net-name { <nn> <> nil } ^min <max2> ^max <garb1> ^com <hcom> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) + (vertical ^net-name { <nn1> <> <nn> <> nil } ^min { <garb4> <= <hcom> } ^max { <garb2> >= <hcom> } ^com <max1> ^layer { <garb3> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + - (vertical ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com { > <max1> < <max2> }) + --> + (modify <h1> ^min (compute <max1> + 1) ^min-net nil) +) + +(p p112 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <max2> > <max1> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + - (vertical ^min <= <hcom> ^max >= <hcom> ^com <max2> ^layer <lay>) + - (horizontal ^min <max2> ^max > <max2> ^com <hcom> ^layer <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com { >= <max1> < <max2> }) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com { >= <max1> < <max2> } ^max-net nil) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com { >= <max1> < <max2> } ^min-net nil) + - (horizontal ^min < <max1> ^max <max1> ^com <hcom> ^layer <lay>) + (vertical ^net-name { <nn1> <> nil } ^min { <garb1> <= <hcom> } ^max { <garb2> >= <hcom> } ^com <max2> ^layer { <garb3> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + - (vertical ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com { >= <max1> < <max2> }) + --> + (modify <h1> ^max (compute <max2> - 1) ^max-net nil) +) + +(p p113 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <max2> > <max1> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + - (vertical ^min <= <hcom> ^max >= <hcom> ^com <max1> ^layer <lay>) + - (horizontal ^min < <max1> ^max <max1> ^com <hcom> ^layer <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com { > <max1> <= <max2> }) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com { > <max1> <= <max2> } ^max-net nil) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com { > <max1> <= <max2> } ^min-net nil) + - (horizontal ^min <max2> ^max > <max2> ^com <hcom> ^layer <lay>) + (vertical ^net-name { <nn1> <> nil } ^min { <garb1> <= <hcom> } ^max { <garb2> >= <hcom> } ^com <max1> ^layer { <garb3> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + - (vertical ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com { > <max1> <= <max2> }) + --> + (modify <h1> ^min (compute <max1> + 1) ^min-net nil) +) + +(p p114 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <max1> ^max { <max2> > <max1> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + (vertical ^net-name { <nn> <> nil } ^min <garb1> ^max <max1> ^com <hcom> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) + - (horizontal ^min <= <hcom> ^max >= <hcom> ^com <max2> ^layer <lay>) + - (vertical ^min <max2> ^max > <max2> ^com <hcom> ^layer <lay>) + - (horizontal ^net-name nil ^min < <hcom> ^max > <hcom> ^com { > <max1> < <max2> }) + - (horizontal ^net-name nil ^min < <hcom> ^max <hcom> ^com { > <max1> < <max2> } ^max-net nil) + - (horizontal ^net-name nil ^min <hcom> ^max > <hcom> ^com { > <max1> < <max2> } ^min-net nil) + (horizontal ^net-name { <nn1> <> <nn> <> nil } ^min { <garb2> <= <hcom> } ^max { <garb3> >= <hcom> } ^com <max2> ^layer { <garb4> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + - (horizontal ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com { > <max1> < <max2> }) + --> + (modify <v1> ^max (compute <max2> - 1) ^max-net nil) +) + +(p p115 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^compo <gy>) + { <v1> (vertical ^net-name nil ^min <vmin> ^max { <gy> > <vmin> } ^com <gx> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { >= <vmin> < <gy> }) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { >= <vmin> < <gy> } ^max-net nil) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { >= <vmin> < <gy> } ^min-net nil) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <vmin> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <vmin> ^max >= <vmin> ^com <gx>) + --> + (modify <v1> ^max (compute <gy> - 1) ^max-net nil) +) + +(p p116 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { <max2> > <gx> } ^com <gy> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> <= <max2> } ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> <= <max2> }) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> <= <max2> } ^max-net nil) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> <= <max2> }) + --> + (modify <h1> ^min (compute <gx> + 1) ^min-net nil) +) + +(p p117 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <vmin> ^max { <vmax> > <vmin> } ^com <vcom> ^layer <lay> ^min-net { <nn> <> nil }) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { <hmax> >= <vcom> > <hmin> } ^com <vmax> ^layer <lay> ^commo <vmin> ^min-net { <> <nn> <> nil } ^max-net { <> <nn> <> nil }) + - (vertical ^net-name nil ^min < <vmax> ^max > <vmax> ^com { > <hmin> < <hmax> }) + - (vertical ^net-name nil ^min < <vmax> ^max <vmax> ^com { > <hmin> < <vcom> } ^max-net nil) + - (vertical ^net-name nil ^min < <vmax> ^max <vmax> ^com { > <vcom> < <hmax> } ^max-net nil) + - (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com { > <hmin> < <hmax> } ^min-net nil) + - (vertical ^net-name { <nn> <> nil } ^min <= <vmax> ^max >= <vmax> ^com { > <hmin> < <hmax> }) + --> + (remove <v1>) +) + +(p p118 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay1> ^compo <cpo1> ^commo <cmo1>) + - (vertical ^net-name nil ^com <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max > <com1> ^com > <max1>) + - (horizontal ^net-name nil ^min < <com1> ^max > <com1> ^com < <min1>) + { <h1> (horizontal ^net-name nil ^min { <min2> < <com1> } ^max { <max2> > <com1> > <min2> } ^com { <com2> >= <min1> <= <max1> } ^layer { <lay2> <> <lay1> } ^compo <cpo2> ^commo <cmo2>) } + - (horizontal ^net-name nil ^min < <com1> ^max > <com1> ^com { >= <min1> <= <max1> } ^layer <lay2>) + { <t1> (to-be-routed ^net-name { <nn2> <> <nn1> } ^no-of-attached-pins <nap>) } + - (horizontal ^status nil ^net-name { <nn2> <> nil } ^min <= <com1> ^max >= <com1>) + (pin ^net-name <nn2> ^pin-x < <com1>) + (pin ^net-name <nn2> ^pin-x > <com1>) + { <b1> (branch-no <pn>) } + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <b1>) + (make horizontal ^min <cmo1> ^max <cpo1> ^com <com2> ^layer <lay2> ^net-name <nn2> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make horizontal ^min <min2> ^max <cmo1> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (make horizontal ^min <cpo1> ^max <max2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <cmo1> ^grid-y <com2> ^grid-layer <lay2> ^came-from east) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <cpo1> ^grid-y <com2> ^grid-layer <lay2> ^came-from west) + (remove <h1>) +) + +(p p119 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay1> ^compo <cpo1> ^commo <cmo1>) + - (vertical ^net-name nil ^com <com1>) + { <h1> (horizontal ^net-name nil ^min { <min2> < <com1> } ^max { <max2> > <com1> > <min2> } ^com { <com2> >= <min1> <= <max1> } ^layer { <lay2> <> <lay1> } ^compo <cpo2> ^commo <cmo2>) } + - (horizontal ^net-name nil ^min < <com1> ^max > <com1> ^com > <com2>) + - (horizontal ^net-name nil ^min < <com1> ^max > <com1> ^com < <com2>) + { <t1> (to-be-routed ^net-name { <nn2> <> <nn1> } ^no-of-attached-pins <nap>) } + - (horizontal ^status nil ^net-name { <nn2> <> nil } ^min <= <com1> ^max >= <com1>) + (pin ^net-name <nn2> ^pin-x < <com1>) + (pin ^net-name <nn2> ^pin-x > <com1>) + { <b1> (branch-no <pn>) } + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <b1>) + (make horizontal ^min <cmo1> ^max <cpo1> ^com <com2> ^layer <lay2> ^net-name <nn2> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make horizontal ^min <min2> ^max <cmo1> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (make horizontal ^min <cpo1> ^max <max2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <cmo1> ^grid-y <com2> ^grid-layer <lay2> ^came-from east) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <cpo1> ^grid-y <com2> ^grid-layer <lay2> ^came-from west) + (remove <h1>) +) + +(p p120 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay1> ^compo <cpo1> ^commo <cmo1>) + - (horizontal ^net-name nil ^com <com1>) + - (vertical ^net-name nil ^min < <com1> ^max > <com1> ^com > <max1>) + - (vertical ^net-name nil ^min < <com1> ^max > <com1> ^com < <min1>) + { <v1> (vertical ^net-name nil ^min { <min2> < <com1> } ^max { <max2> > <com1> > <min2> } ^com { <com2> >= <min1> <= <max1> } ^layer { <lay2> <> <lay1> } ^compo <cpo2> ^commo <cmo2>) } + - (vertical ^net-name nil ^min < <com1> ^max > <com1> ^com { >= <min1> <= <max1> } ^layer <lay2>) + { <t1> (to-be-routed ^net-name { <nn2> <> <nn1> } ^no-of-attached-pins <nap>) } + - (vertical ^status nil ^net-name { <nn2> <> nil } ^min <= <com1> ^max >= <com1>) + (pin ^net-name <nn2> ^pin-y < <com1>) + (pin ^net-name <nn2> ^pin-y > <com1>) + { <b1> (branch-no <pn>) } + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <b1>) + (make vertical ^min <cmo1> ^max <cpo1> ^com <com2> ^layer <lay2> ^net-name <nn2> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make vertical ^min <min2> ^max <cmo1> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (make vertical ^min <cpo1> ^max <max2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com2> ^grid-y <cmo1> ^grid-layer <lay2> ^came-from north) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com2> ^grid-y <cpo1> ^grid-layer <lay2> ^came-from south) + (remove <v1>) +) + +(p p121 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay1> ^compo <cpo1> ^commo <cmo1>) + - (horizontal ^net-name nil ^com <com1>) + { <v1> (vertical ^net-name nil ^min { <min2> < <com1> } ^max { <max2> > <com1> > <min2> } ^com { <com2> >= <min1> <= <max1> } ^layer { <lay2> <> <lay1> } ^compo <cpo2> ^commo <cmo2>) } + - (vertical ^net-name nil ^min < <com1> ^max > <com1> ^com > <com2>) + - (vertical ^net-name nil ^min < <com1> ^max > <com1> ^com < <com2>) + { <t1> (to-be-routed ^net-name { <nn2> <> <nn1> } ^no-of-attached-pins <nap>) } + - (vertical ^status nil ^net-name { <nn2> <> nil } ^min <= <com1> ^max >= <com1>) + (pin ^net-name <nn2> ^pin-y < <com1>) + (pin ^net-name <nn2> ^pin-y > <com1>) + { <b1> (branch-no <pn>) } + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <b1>) + (make vertical ^min <cmo1> ^max <cpo1> ^com <com2> ^layer <lay2> ^net-name <nn2> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make vertical ^min <min2> ^max <cmo1> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (make vertical ^min <cpo1> ^max <max2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com2> ^grid-y <cmo1> ^grid-layer <lay2> ^came-from north) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com2> ^grid-y <cpo1> ^grid-layer <lay2> ^came-from south) + (remove <v1>) +) + +(p p122 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <min2> ^max { <max2> > <min2> } ^com <com2> ^layer <lay2> ^compo <cpo2> ^commo <cmo2>) } + - (horizontal ^net-name nil ^min <= <min2> ^max >= <max2> ^com > <com2>) + - (horizontal ^net-name nil ^min <= <min2> ^max >= <max2> ^com < <com2>) + - (horizontal ^net-name nil ^min <= <min2> ^max >= <max2> ^com <com2> ^layer <> <lay2>) + (congestion ^direction col ^coordinate { <x1> <= <max2> } ^como { <x2> >= <min2> }) + - (horizontal ^net-name nil ^min <= <x2> ^max >= <x1> ^com > <com2>) + - (horizontal ^net-name nil ^min <= <x2> ^max >= <x1> ^com < <com2>) + - (horizontal ^net-name nil ^min <= <x2> ^max >= <x1> ^com <com2> ^layer <> <lay2>) + { <t1> (to-be-routed ^net-name <nn2> ^no-of-attached-pins <nap>) } + - (horizontal ^status nil ^net-name { <nn2> <> nil } ^min <= <x2> ^max >= <x1>) + (pin ^net-name <nn2> ^pin-x <= <x2>) + (pin ^net-name <nn2> ^pin-x >= <x1>) + { <b1> (branch-no <pn>) } + - (horizontal ^net-name { <> <nn2> <> nil } ^min <= <x2> ^max >= <x2> ^com <com2> ^layer <lay2>) + - (vertical ^net-name { <> <nn2> <> nil } ^min <= <com2> ^max >= <com2> ^com <x2> ^layer <lay2>) + - (horizontal ^net-name { <> <nn2> <> nil } ^min <= <x1> ^max >= <x1> ^com <com2> ^layer <lay2>) + - (vertical ^net-name { <> <nn2> <> nil } ^min <= <com2> ^max >= <com2> ^com <x1> ^layer <lay2>) + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <b1>) + (make horizontal ^min <x2> ^max <x1> ^com <com2> ^layer <lay2> ^net-name <nn2> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make horizontal ^min <min2> ^max <x2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (make horizontal ^min <x1> ^max <max2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <x2> ^grid-y <com2> ^grid-layer <lay2> ^came-from east) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <x1> ^grid-y <com2> ^grid-layer <lay2> ^came-from west) + (remove <h1>) +) + +(p p123 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <min1> ^max { <max1> > <min1> } ^com { <com1> <> 1 } ^layer <lay1> ^compo <cpo1> ^commo <cmo1> ^min-net <mnn> ^max-net <xnn>) } + - (horizontal ^net-name nil ^min < <com1> ^max > <com1>) + (horizontal ^net-name nil ^min <com1> ^max { <garb3> > <com1> } ^com { <bhcom> <= <max1> >= <min1> } ^layer <garb4>) + (horizontal ^net-name nil ^min { <garb1> < <com1> } ^max <com1> ^com { <thcom> <= <max1> > <bhcom> } ^layer <garb2>) + - (horizontal ^net-name nil ^min < <com1> ^max <com1> ^com { < <thcom> > <bhcom> }) + - (horizontal ^net-name nil ^min <com1> ^max > <com1> ^com { < <thcom> > <bhcom> }) + { <t1> (to-be-routed ^net-name <nn2> ^no-of-attached-pins <nap>) } + - (vertical ^status nil ^net-name { <nn2> <> nil } ^com <com1>) + - (horizontal ^status nil ^net-name { <nn2> <> nil } ^min <= <com1> ^max >= <com1>) + (pin ^net-name <nn2> ^pin-x < <com1>) + (pin ^net-name <nn2> ^pin-x > <com1>) + { <b1> (branch-no <pn>) } + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <v1> <b1>) + (make vertical ^min <min1> ^max <bhcom> ^com <com1> ^layer <lay1> ^commo <cmo1> ^compo <cpo1> ^max-net <nn2> ^min-net <mnn>) + (make vertical ^min <thcom> ^max <max1> ^com <com1> ^layer <lay1> ^commo <cmo1> ^compo <cpo1> ^min-net <nn2> ^max-net <xnn>) + (make vertical ^min <bhcom> ^max <thcom> ^com <com1> ^layer <lay1> ^commo <cmo1> ^compo <cpo1> ^net-name <nn2> ^pin-name <pn>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com1> ^grid-y <bhcom> ^grid-layer <lay1> ^came-from north) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com1> ^grid-y <thcom> ^grid-layer <lay1> ^came-from south) +) + +(p p124 + (context ^present propagate-constraint) + (ff ^net-name <nn1> ^grid-x <gx> ^grid-y <com2> ^grid-layer <lay1> ^pin-name <egarb1>) + - (vertical ^net-name nil ^min <= <com2> ^max >= <com2> ^com <gx>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com > <com2>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com < <com2>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min < <gx>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^com < <gx>) + { <h1> (horizontal ^net-name nil ^min { <min2> < <gx> } ^max { <max2> >= <gx> > <min2> } ^com <com2> ^layer <lay1> ^compo <cpo2> ^commo <cmo2> ^min-net <nn2>) } + --> + (make horizontal ^min <min2> ^max (compute <gx> - 1) ^com <com2> ^layer <lay1> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (modify <h1> ^min <gx> ^min-net <nn1>) +) + +(p p125 + (context ^present propagate-constraint) + (ff ^net-name <nn1> ^grid-x <gx> ^grid-y <com2> ^grid-layer <lay1> ^pin-name <egarb1>) + - (vertical ^net-name nil ^min <= <com2> ^max >= <com2> ^com <gx>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com > <com2>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com < <com2>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^max > <gx>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^com > <gx>) + { <h1> (horizontal ^net-name nil ^min { <min2> <= <gx> } ^max { <max2> > <gx> > <min2> } ^com <com2> ^layer <lay1> ^compo <cpo2> ^commo <cmo2> ^max-net <nn2>) } + --> + (make horizontal ^min (compute <gx> + 1) ^max <max2> ^com <com2> ^layer <lay1> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (modify <h1> ^max <gx> ^max-net <nn1>) +) + +(p p126 + (context ^present << propagate-constraint extend-total-verti >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> east ^net-name <nn> ^grid-x <max1> ^grid-y <com1> ^grid-layer <lay> ^pin-name <pn>) } + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <garb1> > <max1> } ^com <com1> ^layer <lay> ^compo <cpo1> ^commo <cmo1>) } + - (horizontal ^net-name nil ^min < <max1> ^max <max1> ^com <com1> ^layer <lay>) + - (vertical ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1>) + --> + (modify <h1> ^min (compute <max1> + 1) ^min-net <nn>) + (make horizontal ^min <max1> ^max (compute <max1> + 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo1> ^compo <cpo1>) + (modify <ff1> ^grid-x (compute <max1> + 1) ^came-from west ^can-chng-layer nil) +) + +(p p127 + (context ^present << propagate-constraint extend-total-verti >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> west ^net-name <nn> ^grid-x <max1> ^grid-y <com1> ^grid-layer <lay> ^pin-name <pn>) } + { <h1> (horizontal ^net-name nil ^min <garb1> ^max { <max1> > <garb1> } ^com <com1> ^layer <lay> ^compo <cpo1> ^commo <cmo1>) } + - (horizontal ^net-name nil ^min <max1> ^max > <max1> ^com <com1> ^layer <lay>) + - (vertical ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1>) + --> + (modify <h1> ^max (compute <max1> - 1) ^max-net <nn>) + (make horizontal ^max <max1> ^min (compute <max1> - 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo1> ^compo <cpo1>) + (modify <ff1> ^grid-x (compute <max1> - 1) ^came-from east ^can-chng-layer nil) +) + +(p p128 + (context ^present << propagate-constraint extend-total-verti >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> north ^net-name <nn> ^grid-x <com1> ^grid-y <max1> ^grid-layer <lay> ^pin-name <pn>) } + { <v1> (vertical ^net-name nil ^min <max1> ^max { <garb1> > <max1> } ^com <com1> ^layer <lay> ^compo <cpo1> ^commo <cmo1>) } + - (vertical ^net-name nil ^min < <max1> ^max <max1> ^com <com1> ^layer <lay>) + - (horizontal ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1>) + --> + (modify <v1> ^min (compute <max1> + 1) ^min-net <nn>) + (make vertical ^min <max1> ^max (compute <max1> + 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo1> ^compo <cpo1>) + (modify <ff1> ^grid-y (compute <max1> + 1) ^came-from south ^can-chng-layer nil) +) + +(p p129 + (context ^present << propagate-constraint extend-total-verti >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> south ^net-name <nn> ^grid-x <com1> ^grid-y <max1> ^grid-layer <lay> ^pin-name <pn>) } + { <v1> (vertical ^net-name nil ^min <garb1> ^max { <max1> > <garb1> } ^com <com1> ^layer <lay> ^compo <cpo1> ^commo <cmo1>) } + - (vertical ^net-name nil ^min <max1> ^max > <max1> ^com <com1> ^layer <lay>) + - (horizontal ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1>) + --> + (modify <v1> ^max (compute <max1> - 1) ^max-net <nn>) + (make vertical ^max <max1> ^min (compute <max1> - 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo1> ^compo <cpo1>) + (modify <ff1> ^grid-y (compute <max1> - 1) ^came-from north ^can-chng-layer nil) +) + +(p p130 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <h1> (horizontal ^status nil ^net-name <nn> ^min <min> ^max { <max> > <min> } ^com <com> ^layer <lay> ^pin-name <pn> ^max-net <gar1>) } + { <h2> (horizontal ^status nil ^net-name <nn> ^min <max> ^max { <max2> > <max> } ^com <com> ^layer <lay> ^pin-name <pn> ^max-net <nn1>) } + --> + (modify <h1> ^max <max2> ^max-net <nn1>) + (remove <h2>) +) + +(p p131 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <v1> (vertical ^status nil ^net-name <nn> ^min <min> ^max { <max> > <min> } ^com <com> ^layer <lay> ^pin-name <pn> ^max-net <gar1>) } + { <v2> (vertical ^status nil ^net-name <nn> ^min <max> ^max { <max2> > <max> } ^com <com> ^layer <lay> ^pin-name <pn> ^max-net <nn1>) } + --> + (modify <v1> ^max <max2> ^max-net <nn1>) + (remove <v2>) +) + +(p p132 + (context ^present propagate-constraint) + { <h1> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <gar1> ^max <max> ^com <com> ^layer <lay> ^pin-name <pn>) } + { <h2> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <max2> ^com <com> ^layer <lay> ^pin-name { <pn1> <> <pn> }) } + (vertical ^status nil ^net-name { <nn> <> nil } ^pin-name <pn1>) + --> + (modify <h1> ^max <max2>) + (remove <h2>) +) + +(p p133 + (context ^present propagate-constraint) + { <h1> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <gar1> ^com <com> ^layer <lay> ^pin-name <pn>) } + { <h2> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min2> ^max <min> ^com <com> ^layer <lay> ^pin-name { <pn1> <> <pn> }) } + (vertical ^status nil ^net-name { <nn> <> nil } ^pin-name <pn1>) + --> + (modify <h1> ^min <min2>) + (remove <h2>) +) + +(p p134 + (context ^present propagate-constraint) + { <v1> (vertical ^status nil ^net-name { <nn> <> nil } ^min <gar1> ^max <max> ^com <com> ^layer <lay> ^pin-name <pn>) } + { <v2> (vertical ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <max2> ^com <com> ^layer <lay> ^pin-name { <pn1> <> <pn> }) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^pin-name <pn1>) + --> + (modify <v1> ^max <max2>) + (remove <v2>) +) + +(p p135 + (context ^present propagate-constraint) + { <v1> (vertical ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <gar1> ^com <com> ^layer <lay> ^pin-name <pn>) } + { <v2> (vertical ^status nil ^net-name { <nn> <> nil } ^min <min2> ^max <min> ^com <com> ^layer <lay> ^pin-name { <pn1> <> <pn> }) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^pin-name <pn1>) + --> + (modify <v1> ^min <min2>) + (remove <v2>) +) + +(p p136 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> east ^net-name <nn> ^grid-x <max1> ^grid-y <com1> ^grid-layer <lay> ^pin-name <pn>) } + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <garb1> > <max1> } ^com <com1> ^layer <lay> ^compo <cpo> ^commo <cmo>) } + - (vertical ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1> ^layer <lay>) + - (horizontal ^net-name nil ^min < <max1> ^max <max1> ^com <com1> ^layer <lay>) + --> + (modify <h1> ^min (compute <max1> + 1) ^min-net <nn>) + (make horizontal ^min <max1> ^max (compute <max1> + 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^compo <cpo> ^commo <cmo>) + (modify <ff1> ^grid-x (compute <max1> + 1) ^came-from west ^can-chng-layer nil) +) + +(p p137 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> west ^net-name <nn> ^grid-x <max1> ^grid-y <com1> ^grid-layer <lay> ^pin-name <pn>) } + { <h1> (horizontal ^net-name nil ^min <garb1> ^max { <max1> > <garb1> } ^com <com1> ^layer <lay> ^compo <cpo> ^commo <cmo>) } + - (vertical ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1> ^layer <lay>) + - (horizontal ^net-name nil ^min <max1> ^max > <max1> ^com <com1> ^layer <lay>) + --> + (modify <h1> ^max (compute <max1> - 1) ^max-net <nn>) + (make horizontal ^max <max1> ^min (compute <max1> - 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^compo <cpo> ^commo <cmo>) + (modify <ff1> ^grid-x (compute <max1> - 1) ^came-from east ^can-chng-layer nil) +) + +(p p138 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> north ^net-name <nn> ^grid-x <com1> ^grid-y <max1> ^grid-layer <lay> ^pin-name <pn>) } + { <v1> (vertical ^net-name nil ^min <max1> ^max { <garb1> > <max1> } ^com <com1> ^layer <lay> ^compo <cpo> ^commo <cmo>) } + - (horizontal ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1> ^layer <lay>) + - (vertical ^net-name nil ^min < <max1> ^max <max1> ^com <com1> ^layer <lay>) + --> + (modify <v1> ^min (compute <max1> + 1) ^min-net <nn>) + (make vertical ^min <max1> ^max (compute <max1> + 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^compo <cpo> ^commo <cmo>) + (modify <ff1> ^grid-y (compute <max1> + 1) ^came-from south ^can-chng-layer nil) +) + +(p p139 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> south ^net-name <nn> ^grid-x <com1> ^grid-y <max1> ^grid-layer <lay> ^pin-name <pn>) } + { <v1> (vertical ^net-name nil ^min <garb1> ^max { <max1> > <garb1> } ^com <com1> ^layer <lay> ^compo <cpo> ^commo <cmo>) } + - (horizontal ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1> ^layer <lay>) + - (vertical ^net-name nil ^min <max1> ^max > <max1> ^com <com1> ^layer <lay>) + --> + (modify <v1> ^max (compute <max1> - 1) ^max-net <nn>) + (make vertical ^max <max1> ^min (compute <max1> - 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^compo <cpo> ^commo <cmo>) + (modify <ff1> ^grid-y (compute <max1> - 1) ^came-from north ^can-chng-layer nil) +) + +(p p140 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com> ^max >= <com> ^com { >= <min> <= <max> } ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + - (included <nn> <pn1>) + (included <nn> <pn2>) + --> + (make included <nn> <pn1>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p141 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com> ^max >= <com> ^com { >= <min> <= <max> } ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + (included <nn> <pn1>) + - (included <nn> <pn2>) + --> + (make included <nn> <pn2>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p142 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <max> ^com <com> ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + (included <nn> <pn1>) + - (included <nn> <pn2>) + --> + (make included <nn> <pn2>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p143 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <egarb4> ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <max> ^com <com> ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + - (included <nn> <pn1>) + (included <nn> <pn2>) + --> + (make included <nn> <pn1>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p144 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <egarb4> ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <max> ^com <com> ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + (included <nn> <pn1>) + - (included <nn> <pn2>) + --> + (make included <nn> <pn2>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p145 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <max> ^com <com> ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + - (included <nn> <pn1>) + (included <nn> <pn2>) + --> + (make included <nn> <pn1>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p146 + { <c1> (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) } + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + { <n1> (net ^net-name <nn> ^net-no-of-pins <nap>) } + --> + (remove <c1> <t1>) + (make join-routed-net <nn>) + (modify <n1> ^net-is-routed yes) +) + +(p p147 + { <c1> (context ^present check-for-routed-net) } + --> + (remove <c1>) + (make context ^present move-ff) +) + +(p p148 + { <con> (context ^present move-ff) } + --> + (modify <con> ^present set-min-max) +) + +(p p149 + { <con> (context ^present set-min-max) } + --> + (remove <con>) + (make context ^present propagate-constraint) +) + +(p p150 + (context ^present propagate-constraint) + { <c1> (constraint ^pin-name-2 <pn>) } + - (ff ^pin-name <pn>) + --> + (remove <c1>) +) + +(p p151 + (context ^present propagate-constraint) + { <c1> (constraint ^pin-name-1 <pn>) } + - (ff ^pin-name <pn>) + --> + (remove <c1>) +) + +(p p152 + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <ff2> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb2> ^pin-name <> <pn>) } + --> + (remove <ff1> <ff2>) +) + +(p p153 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn>) } + { <ff2> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy2> ^grid-layer <lay> ^pin-name <> <pn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy1>) + { <v1> (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1> <ff2>) + (make vertical ^min <min> ^max <gy1> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <v1> ^min <gy2> ^min-net <nn>) + (make vertical ^min <gy1> ^max <gy2> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p154 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn>) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <gy2> ^layer <lay> ^compo <egarb1> ^commo <gy1> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy2>) + { <v1> (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1>) + (make vertical ^min <min> ^max <gy1> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <v1> ^min <gy2> ^min-net <nn>) + (make vertical ^min <gy1> ^max <gy2> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p155 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy2> ^grid-layer <lay> ^pin-name <pn>) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <gy1> ^layer <lay> ^compo <gy2> ^commo <egarb1> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1>) + { <v1> (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1>) + (make vertical ^min <min> ^max <gy1> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <v1> ^min <gy2> ^min-net <nn>) + (make vertical ^min <gy1> ^max <gy2> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p156 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) } + (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> > <gx1> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^pin-name <garb1>) + { <ff2> (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> <= <max> } ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx1>) + { <h1> (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1> <ff2>) + (make horizontal ^min <min> ^max <gx1> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <h1> ^min <gx2> ^min-net <nn>) + (make horizontal ^min <gx1> ^max <gx2> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p157 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) } + (vertical ^status nil ^net-name { <nn> <> nil } ^min { <garb1> <= <gy> } ^max { <garb2> >= <gy> } ^com <gx2> ^layer <lay> ^compo <egarb1> ^commo <gx1> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-x <gx2> ^grid-y <gy>) + { <h1> (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1>) + (make horizontal ^min <min> ^max <gx1> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <h1> ^min <gx2> ^min-net <nn>) + (make horizontal ^min <gx1> ^max <gx2> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p158 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx2> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) } + (vertical ^status nil ^net-name { <nn> <> nil } ^min { <garb1> <= <gy> } ^max { <garb2> >= <gy> } ^com <gx1> ^layer <lay> ^compo <gx2> ^commo <egarb1> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy>) + { <h1> (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1>) + (make horizontal ^min <min> ^max <gx1> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <h1> ^min <gx2> ^min-net <nn>) + (make horizontal ^min <gx1> ^max <gx2> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p159 + (context ^present propagate-constraint) + { <ff1> (ff ^can-chng-layer <> no ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay>) } + - (vertical ^net-name nil ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (vertical ^net-name <> nil ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + - (horizontal ^net-name <> nil ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { >= <gy> > <vmin> } ^com <gx> ^layer { <lay2> <> <lay> }) + --> + (modify <ff1> ^grid-layer <lay2> ^can-chng-layer no) +) + +(p p160 + (context ^present propagate-constraint) + { <ff1> (ff ^can-chng-layer <> no ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay>) } + - (vertical ^net-name nil ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (vertical ^net-name <> nil ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + - (horizontal ^net-name <> nil ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { >= <gx> > <hmin> } ^com <gy> ^layer { <lay2> <> lay> }) + --> + (modify <ff1> ^grid-layer <lay2> ^can-chng-layer no) +) + +(p p161 + (context ^present propagate-constraint) + { <ff1> (ff ^can-chng-layer <> no ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay>) } + - (horizontal ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + - (vertical ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + --> + (modify <ff1> ^can-chng-layer no) +) + +(p p162 + (context ^present << propagate-constraint move-ff >>) + { <ff1> (ff ^can-chng-layer <> no ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay>) } + (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + --> + (modify <ff1> ^can-chng-layer no) +) + +(p p163 + (context ^present << propagate-constraint move-ff >>) + { <ff1> (ff ^can-chng-layer <> no ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay>) } + (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + --> + (modify <ff1> ^can-chng-layer no) +) + +(p p164 + (context ^present propagate-constraint) + { <ff1> (ff ^can-chng-layer no ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn>) } + { <ff2> (ff ^can-chng-layer no ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay2> ^pin-name <garb1>) } + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx2>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy1>) + { <h1> (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> >= <gx1> > <hmin> } ^com <gy1> ^layer <lay1> ^compo <hcpo> ^commo <gy2> ^min-net <hnn1>) } + { <v1> (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> >= <gy1> > <vmin> } ^com <gx2> ^layer <lay2> ^compo <gx1> ^commo <vcmo> ^min-net <vnn1>) } + --> + (make horizontal ^min <hmin> ^max <gx2> ^com <gy1> ^commo <gy2> ^compo <hcpo> ^layer <lay1> ^min-net <hnn1> ^max-net <nn>) + (modify <h1> ^min <gx1> ^min-net <nn>) + (make vertical ^min <vmin> ^max <gy2> ^com <gx2> ^commo <vcmo> ^compo <gx1> ^layer <lay2> ^min-net <vnn1> ^max-net <nn>) + (modify <v1> ^min <gy1> ^min-net <nn>) + (remove <ff1> <ff2>) + (make horizontal ^min <gx2> ^max <gx1> ^com <gy1> ^commo <gy2> ^compo <hcpo> ^layer <lay1> ^net-name <nn> ^pin-name <pn>) + (make vertical ^min <gy2> ^max <gy1> ^com <gx2> ^commo <vcmo> ^compo <gx1> ^layer <lay2> ^net-name <nn> ^pin-name <pn>) +) + +(p p165 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <garb1> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min <garb2> ^max { <max> > <garb2> } ^com <com> ^layer <lay> ^max-net <> <nn>) } + --> + (modify <v1> ^max-net <nn>) +) + +(p p166 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <min> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min <min> ^max { <garb2> > <min> } ^com <com> ^layer <lay> ^min-net <> <nn>) } + --> + (modify <v1> ^min-net <nn>) +) + +(p p167 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <max> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min { <garb1> < <max> } ^max <max> ^com { >= <hmin> <= <hmax> } ^layer <lay> ^max-net <> <nn>) } + --> + (modify <v1> ^max-net <nn>) +) + +(p p168 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <min> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min <min> ^max { <garb1> > <min> } ^com { >= <hmin> <= <hmax> } ^layer <lay> ^min-net <> <nn>) } + --> + (modify <v1> ^min-net <nn>) +) + +(p p169 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <garb1> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <h1> (horizontal ^net-name nil ^min <garb2> ^max { <max> > <garb2> } ^com <com> ^layer <lay> ^max-net <> <nn>) } + --> + (modify <h1> ^max-net <nn>) +) + +(p p170 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <min> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <h1> (horizontal ^net-name nil ^min <min> ^max { <garb2> > <min> } ^com <com> ^layer <lay> ^min-net <> <nn>) } + --> + (modify <h1> ^min-net <nn>) +) + +(p p171 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <max> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <h1> (horizontal ^net-name nil ^min <garb1> ^max { <max> > <garb1> } ^com { >= <vmin> <= <vmax> } ^layer <lay> ^max-net <> <nn>) } + --> + (modify <h1> ^max-net <nn>) +) + +(p p172 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <min> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <h1> (horizontal ^net-name nil ^min <min> ^max { <garb1> > <min> } ^com { >= <vmin> <= <vmax> } ^layer <lay> ^min-net <> <nn>) } + --> + (modify <h1> ^min-net <nn>) +) + +(p p173 + (context ^present propagate-constraint) + { <ff1> (ff ^can-chng-layer no ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn>) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <gy2> ^layer <garb3> ^compo <garb4> ^commo <gy1> ^pin-name <> <pn>) + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^com <gy2>) + - (vertical ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx>) + { <v1> (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1>) + (make vertical ^min <min> ^max <gy1> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <v1> ^min <gy2> ^min-net <nn>) + (make vertical ^min <gy1> ^max <gy2> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p174 + (join-routed-net <nn>) + { <h1> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <com> ^layer <lay> ^compo <garb1> ^commo <garb2>) } + { <h2> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <max2> ^com <com> ^layer <lay> ^compo <garb3> ^commo <garb4>) } + --> + (modify <h1> ^max <max2>) + (remove <h2>) +) + +(p p175 + (join-routed-net <nn>) + { <v1> (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <max> ^com <com> ^layer <lay> ^compo <garb2> ^commo <garb3>) } + { <v2> (vertical ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <max2> ^com <com> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + --> + (modify <v1> ^max <max2>) + (remove <v2>) +) + +(p p176 + { <j1> (join-routed-net <nn>) } + --> + (remove <j1>) + (make move-via <nn>) +) + +(p p177 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <vlayer> ^pin-name <egarb1>) + (horizontal ^net-name nil ^min <hmin2> ^max { <gx> > <hmin2> } ^com <vmax> ^layer <vlayer> ^compo <egarb8> ^commo <egarb9>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { < <vmax> > <gy> }) + { <v1> (vertical ^net-name nil ^min { <garb1> <= <gy> } ^max { <vmax> > <garb1> > <gy> } ^com <gx> ^layer <vlayer> ^commo <cmo> ^compo <cpo> ^max-net <maxn>) } + (horizontal ^net-name { <> <nn> <> nil } ^min { <hmin1> <= <gx> } ^max >= <gx> ^com <vmax> ^layer <> <vlayer>) + (vertical ^net-name { <> <nn> <> nil } ^min <= <vmax> ^max >= <vmax> ^com { <vcom> < <gx> >= <hmin1> >= <hmin2> } ^layer <vlayer>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com <vmax>) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { < <vmax> > <gy> } ^max-net nil) + - (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <gx>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmax> ^max > <vmax> ^com <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <gx> ^max > <gx> ^com <vmax>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { < <vmax> > <gy> } ^min-net nil) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { < <vmax> > <gy> }) + - (vertical ^net-name nil ^min < <vmax> ^max > <vmax> ^com { < <gx> > <vcom> }) + - (vertical ^net-name nil ^min < <vmax> ^max <vmax> ^com { < <gx> > <vcom> } ^max-net nil) + - (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com { < <gx> > <vcom> } ^min-net nil) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <vmax> ^max >= <vmax> ^com { < <gx> > <vcom> }) + --> + (make vertical ^min (compute <gy> + 1) ^max <vmax> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <vlayer> ^max-net <maxn>) + (modify <v1> ^max <gy> ^max-net <nn>) +) + +(p p178 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <layer> ^pin-name <pn>) + { <h1> (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> > <gx> > <hmin> } ^com <gy> ^layer <layer> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (vertical ^net-name { <> <nn> <> nil } ^min <cpo> ^max { <garb2> >= <cpo> } ^com <vcom> ^layer <layer1> ^compo <vcpo> ^commo <gx>) + (horizontal ^net-name { <> <nn> <> nil } ^min { <garb3> <= <vcom> } ^max { <garb4> >= <vcom> } ^com <cpo> ^layer <> <layer1> ^compo <garb5> ^commo <gy>) + (vertical ^net-name { <> <nn> <> nil } ^min { <garb6> <= <cmo> } ^max <cmo> ^com <vcom> ^layer <layer2> ^compo <vcpo> ^commo <gx>) + (horizontal ^net-name { <> <nn> <> nil } ^min { <garb7> <= <vcom> } ^max { <garb8> >= <vcom> } ^com <cmo> ^layer <> <layer2> ^compo <gy> ^commo <garb9>) + (vertical ^net-name { <> <nn> <> nil } ^min { <garb13> <= <gy> } ^max { <garb14> >= <gy> } ^com <vcpo> ^layer <layer3> ^compo <garb10> ^commo <vcom>) + (horizontal ^net-name { <> <nn> <> nil } ^min { <garb11> <= <vcpo> } ^max { <garb12> >= <vcpo> } ^com <gy> ^layer <> <layer3> ^compo <cpo> ^commo <cmo>) + --> + (make horizontal ^min (compute <gx> + 1) ^max <hmax> ^com <gy> ^compo <cpo> ^commo <cmo> ^layer <layer> ^max-net <mn>) + (modify <h1> ^max <gx> ^max-net <nn>) +) + +(p p179 + (context ^present propagate-constraint) + { <ff1> (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^pin-name <pn>) } + (vertical ^net-name { <> <nn> <> nil } ^min { <vmin> <= <gy> } ^max { <vmax> >= <gy> } ^com <vcom> ^layer <lay2> ^compo <garb1> ^commo <gx>) + (vertical ^net-name { <> <nn> <> nil } ^min { <vmax2> > <gy> <= <vmax> } ^max <garb4> ^com <gx> ^layer <lay4>) + (vertical ^net-name { <> <nn> <> nil } ^min <garb2> ^max { <vmin2> < <gy> >= <vmin> } ^com <gx> ^layer <lay3>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmin2> < <gy> }) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmin2> < <gy> } ^layer <> <lay2> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmin2> < <gy> } ^max-net nil) + - (horizontal ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { > <vmin2> < <gy> }) + (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <vmin2> ^layer <> <lay3>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmax2> }) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmax2> } ^layer <> <lay2> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmax2> } ^max-net nil) + - (horizontal ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmax2> }) + (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <vmax2> ^layer <> <lay4>) + { <h1> (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> >= <vcom> > <hmin> } ^com <gy> ^layer { <lay5> <> <lay2> } ^compo <hcpo> ^commo <hcmo> ^max-net <mn>) } + --> + (make horizontal ^layer <lay5> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <nn> ^max-net <mn> ^min <vcom> ^max <hmax>) + (modify <h1> ^max <gx> ^max-net <nn>) + (make horizontal ^layer <lay5> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn> ^min <gx> ^max <vcom>) + (modify <ff1> ^grid-x <vcom> ^grid-layer <lay5> ^can-chng-layer no) +) + +(p p180 + (context ^present propagate-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <vmax> ^com <vcom> ^layer <lay1> ^compo <cpo> ^commo <cmo>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <garb2> <= <vcom> } ^max { <garb3> >= <vcom> } ^com <vmax> ^layer { <garb4> <> <lay1> }) + (vertical ^net-name { <nn1> <> <nn> <> nil } ^min { <vmin> > <vmax> } ^max <garb5> ^com <vcom> ^layer <lay2>) + (horizontal ^net-name { <nn1> <> nil } ^min { <garb6> <= <vcom> } ^max { <garb7> >= <vcom> } ^com <vmin> ^layer { <garb8> <> <lay2> }) + (vertical ^net-name { <> <nn> <> nil } ^min { <vmin2> <= <vmax> } ^max { <vmax2> >= <vmin> } ^com <cpo> ^layer <lay3>) + { <v1> (vertical ^net-name nil ^min <vmax> ^max { <vmax3> > <vmax> } ^com <vcom> ^layer <lay3>) } + - (vertical ^net-name nil ^min <vmax3> ^com <vcom>) + - (horizontal ^net-name nil ^min < <vcom> ^max > <vcom> ^com { > <vmax> <= <vmax3> }) + - (horizontal ^net-name nil ^min <vcom> ^max > <vcom> ^com { > <vmax> <= <vmax3> } ^layer <> <lay3> ^min-net nil) + - (horizontal ^net-name nil ^min < <vcom> ^max <vcom> ^com { > <vmax> <= <vmax3> } ^max-net nil) + - (horizontal ^net-name { <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com { > <vmax> <= <vmax3> }) + --> + (modify <v1> ^min (compute <vmax> + 1) ^min-net nil) +) + +(p p181 + (context ^present propagate-constraint) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) } + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> } ^grid-y <garb1> ^grid-layer <lay> ^pin-name <> <pn>) + - (vertical ^com { > <gx> < <gx2> }) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { <egarb1> > <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + - (vertical ^net-name nil ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2>) + --> + (modify <h1> ^min (compute <gx> + 1) ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <gx> ^com <gy> ^max (compute <gx> + 1) ^commo <hcmo> ^compo <hcpo> ^layer <lay>) + (modify <ff1> ^grid-x (compute <gx> + 1) ^came-from west) +) + +(p p182 + (context ^present propagate-constraint) + { <v3> (vertical ^net-name nil ^min <vmin2> ^max { <vmax2> > <vmin2> } ^com <vcom> ^layer <garb1> ^compo <vcpo> ^commo <egarb1>) } + (congestion ^direction row ^coordinate <vmax2> ^como <vmin2>) + - (horizontal ^status nil ^min < <vcom> ^max >= <vcom> ^com { <= <vmax2> >= <vmin2> }) + - (vertical ^status nil ^min <vmax2> ^max > <vmax2> ^com <vcom>) + - (vertical ^status nil ^max <vmin2> ^min < <vmin2> ^com <vcom>) + (vertical ^net-name nil ^min { <vmin> <= <vmin2> } ^max { > <vmin> >= <vmax2> } ^com <vcpo> ^layer <lay>) + (horizontal ^net-name nil ^min <vcom> ^max { <egarb2> > <vcom> } ^com <vmax2> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) + (horizontal ^net-name nil ^min <vcom> ^max { <egarb5> > <vcom> } ^com <vmin2> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) + --> + (remove <v3>) +) + +(p p183 + (context ^present propagate-constraint) + { <v3> (vertical ^net-name nil ^min <vmin2> ^max { <vmax2> > <vmin2> } ^com <vcom> ^layer <garb1> ^compo <garb2> ^commo <vcmo>) } + (congestion ^direction row ^coordinate <vmax2> ^como <vmin2>) + - (horizontal ^status nil ^min <= <vcom> ^max > <vcom> ^com { <= <vmax2> >= <vmin2> }) + - (vertical ^status nil ^min <vmax2> ^max > <vmax2> ^com <vcom>) + - (vertical ^status nil ^max <vmin2> ^min < <vmin2> ^com <vcom>) + (vertical ^net-name nil ^min { <vmin> <= <vmin2> } ^max { > <vmin> >= <vmax2> } ^com <vcmo> ^layer <lay>) + (horizontal ^net-name nil ^min <egarb1> ^max { <vcom> > <egarb1> } ^com <vmax2> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) + (horizontal ^net-name nil ^min <egarb6> ^max { <vcom> > <egarb6> } ^com <vmin2> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) + --> + (remove <v3>) +) + +(p p184 + (context ^present propagate-constraint) + { <h3> (horizontal ^net-name nil ^min <hmin2> ^max { <hmax2> > <hmin2> } ^com <hcom> ^layer <garb1> ^compo <hcpo> ^commo <egarb1>) } + (congestion ^direction col ^coordinate <hmax2> ^como <hmin2>) + - (vertical ^status nil ^min < <hcom> ^max >= <hcom> ^com { <= <hmax2> >= <hmin2> }) + - (horizontal ^status nil ^min <hmax2> ^max > <hmax2> ^com <hcom>) + - (horizontal ^status nil ^max <hmin2> ^min < <hmin2> ^com <hcom>) + (horizontal ^net-name nil ^min { <hmin> <= <hmin2> } ^max { > <hmin> >= <hmax2> } ^com <hcpo> ^layer <lay>) + (vertical ^net-name nil ^min <hcom> ^max { <egarb2> > <hcom> } ^com <hmax2> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) + (vertical ^net-name nil ^min <hcom> ^max { <egarb5> > <hcom> } ^com <hmin2> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) + --> + (remove <h3>) +) + +(p p185 + (context ^present propagate-constraint) + { <h3> (horizontal ^net-name nil ^min <hmin2> ^max { <hmax2> > <hmin2> } ^com <hcom> ^layer <garb1> ^compo <garb2> ^commo <hcmo>) } + (congestion ^direction col ^coordinate <hmax2> ^como <hmin2>) + - (vertical ^status nil ^min <= <hcom> ^max > <hcom> ^com { <= <hmax2> >= <hmin2> }) + - (horizontal ^status nil ^min <hmax2> ^max > <hmax2> ^com <hcom>) + - (horizontal ^status nil ^max <hmin2> ^min < <hmin2> ^com <hcom>) + (horizontal ^net-name nil ^min { <hmin> <= <hmin2> } ^max { > <hmin> >= <hmax2> } ^com <hcmo> ^layer <lay>) + (vertical ^net-name nil ^min <egarb1> ^max { <hcom> > <egarb1> } ^com <hmax2> ^layer <lay> ^compo <egarb3> ^compo <egarb4>) + (vertical ^net-name nil ^min <egarb5> ^max { <hcom> > <egarb5> } ^com <hmin2> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) + --> + (remove <h3>) +) + +(p p538 + (finally-routed <nn>) + { <i1> (included <nn>) } + --> + (remove <i1>) +) + +(p p539 + (finally-routed <nn>) + { <ff1> (ff ^net-name <nn>) } + --> + (remove <ff1>) +) + +(p p540 + (finally-routed <nn>) + { <c1> (constraint ^constraint-type << vertical horizontal >> ^net-name-1 <nn>) } + --> + (remove <c1>) +) + +(p p541 + (finally-routed <nn>) + { <c1> (constraint ^constraint-type << vertical horizontal >> ^net-name-2 <nn>) } + --> + (remove <c1>) +) + +(p p542 + (finally-routed <nn>) + { <c> (<< horizontal-cycle vertical-cycle >> <nn>) } + --> + (remove <c>) +) + +(p p543 + (finally-routed <nn>) + { <c1> (constraint ^constraint-type << vertical horizontal >> ^net-name-2 <nn>) } + --> + (remove <c1>) +) + +(p p544 + (finally-routed <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <garb1> ^commo <garb2>) + { <h1> (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { <hmax> > <hmin> >= <vcom> } ^com { <hcom> >= <vmin> <= <vmax> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <nn1>) } + --> + (make horizontal ^min <hmin> ^max (compute <vcom> - 1) ^com <hcom> ^compo <hcpo> ^commo <hcmo> ^layer <lay> ^min-net <nn1>) + (modify <h1> ^min (compute <vcom> + 1) ^min-net nil) +) + +(p p545 + (finally-routed <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <garb1> ^commo <garb2>) + { <v1> (vertical ^net-name nil ^min { <vmin> <= <hcom> } ^max { <vmax> > <vmin> >= <hcom> } ^com { <vcom> >= <hmin> <= <hmax> } ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <nn1>) } + --> + (make vertical ^min <vmin> ^max (compute <hcom> - 1) ^com <vcom> ^compo <vcpo> ^commo <vcmo> ^layer <lay> ^min-net <nn1>) + (modify <v1> ^min (compute <hcom> + 1) ^min-net nil) +) + +(p p546 + (finally-routed <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <rmax> ^com <com> ^layer <lay> ^compo <garb4> ^commo <garb3>) + { <v1> (vertical ^net-name nil ^min <rmax> ^max { <garb2> > <rmax> } ^com <com> ^layer <lay> ^compo <garb6> ^commo <garb5>) } + --> + (modify <v1> ^min (compute <rmax> + 1) ^min-net nil) +) + +(p p547 + (finally-routed <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <rmin> ^max <garb1> ^com <com> ^layer <lay> ^compo <garb3> ^commo <garb4>) + { <v1> (vertical ^net-name nil ^min <garb2> ^max { <rmin> > <garb2> } ^com <com> ^layer <lay> ^compo <garb5> ^commo <garb6>) } + --> + (modify <v1> ^max (compute <rmin> - 1) ^max-net nil) +) + +(p p548 + (finally-routed <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <rmax> ^com <com> ^layer <lay> ^compo <garb3> ^commo <garb4>) + { <h1> (horizontal ^net-name nil ^min <rmax> ^max { <garb2> > <rmax> } ^com <com> ^layer <lay> ^compo <garb5> ^commo <garb6>) } + --> + (modify <h1> ^min (compute <rmax> + 1) ^min-net nil) +) + +(p p549 + (finally-routed <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <rmin> ^max <garb1> ^com <com> ^layer <lay> ^compo <garb3> ^commo <garb4>) + { <h1> (horizontal ^net-name nil ^min <garb2> ^max { <rmin> > <garb2> } ^com <com> ^layer <lay> ^compo <garb5> ^commo <garb6>) } + --> + (modify <h1> ^max (compute <rmin> - 1) ^max-net nil) +) + +(p p550 + { <f1> (finally-routed <nn>) } + --> + (remove <f1>) + (make context ^present remove-routed-net-segments <nn>) +) + +(p p551 + (context ^present remove-routed-net-segments <nn>) + { <h1> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <c> ^layer <lay> ^compo <garb1> ^commo <garb2>) } + --> + (modify <h1> ^status routed) + (write (crlf) |hor | <nn> <min> <max> <c> <lay>) +) + +(p p552 + (context ^present remove-routed-net-segments <nn>) + { <v1> (vertical ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <c> ^layer <lay> ^compo <garb1> ^commo <garb2>) } + --> + (modify <v1> ^status routed) + (write (crlf) |ver | <nn> <min> <max> <c> <lay>) +) + +(p p553 + (context ^present remove-routed-net-segments <nn>) + { <h> (horizontal-s ^net-name <nn>) } + --> + (remove <h>) +) + +(p p554 + (context ^present remove-routed-net-segments <nn>) + { <v> (vertical-s ^net-name <nn>) } + --> + (remove <v>) +) + +(p p555 + (context ^present remove-routed-net-segments <nn>) + { <p> (pin ^net-name <nn>) } + --> + (remove <p>) +) + +(p p556 + (context ^present remove-routed-net-segments <nn>) + { <n> (net ^net-name <nn>) } + --> + (remove <n>) +) + +(p p557 + { <c1> (context ^present remove-routed-net-segments) } + --> + (remove <c1>) + (make context ^present check-for-routed-net) +) + +(p p32 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-top-pins 1 ^no-of-bottom-pins 1) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + { <v> (vertical ^net-name nil ^min <gy2> ^max > <gy2> ^com <gx2> ^layer <lay> ^commo <cmo> ^compo <gx1> ^min-net <garb2>) } + - (horizontal ^net-name nil ^min <= <gx2> ^max >= <gx1> ^com <gy2> ^layer <lay>) + (congestion ^direction row ^coordinate <gy3> ^como <gy2>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy3> ^max >= <gy3> ^com <gx2> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy3> ^layer <lay>) + --> + (modify <v> ^min <gy3> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn2> ^min <gy2> ^max <gy3> ^com <gx2> ^compo <gx1> ^commo <cmo> ^layer <lay>) + (modify <ff> ^grid-y <gy3> ^can-chng-layer nil ^came-from south) +) + +(p p33 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-top-pins 1 ^no-of-bottom-pins 1) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + { <v> (vertical ^net-name nil ^min < <gy1> ^max <gy1> ^com <gx1> ^layer <lay> ^commo <gx2> ^compo <cpo> ^min-net <garb2>) } + - (horizontal ^net-name nil ^min <= <gx2> ^max >= <gx1> ^com <gy1> ^layer <lay>) + (congestion ^direction row ^coordinate <gy1> ^como <gy3>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy3> ^max >= <gy3> ^com <gx1> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy3> ^layer <lay>) + --> + (modify <v> ^max <gy3> ^max-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn1> ^min <gy3> ^max <gy1> ^com <gx1> ^compo <cpo> ^commo <gx2> ^layer <lay>) + (modify <ff> ^grid-y <gy3> ^can-chng-layer nil ^came-from north) +) + +(p p34 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-top-pins 1 ^no-of-bottom-pins 1) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + { <v> (vertical ^net-name nil ^min <gy2> ^max > <gy2> ^com <gx2> ^layer <lay> ^commo <gx1> ^compo <cpo> ^min-net <garb2>) } + - (horizontal ^net-name nil ^min <= <gx1> ^max >= <gx2> ^com <gy2> ^layer <lay>) + (congestion ^direction row ^coordinate <gy3> ^como <gy2>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy3> ^max >= <gy3> ^com <gx2> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy3> ^layer <lay>) + --> + (modify <v> ^min <gy3> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn2> ^min <gy2> ^max <gy3> ^com <gx2> ^compo <cpo> ^commo <gx1> ^layer <lay>) + (modify <ff> ^grid-y <gy3> ^can-chng-layer nil ^came-from south) +) + +(p p35 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-top-pins 1 ^no-of-bottom-pins 1) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + { <v> (vertical ^net-name nil ^min < <gy1> ^max <gy1> ^com <gx1> ^layer <lay> ^commo <cmo> ^compo <gx2> ^min-net <garb2>) } + - (horizontal ^net-name nil ^min <= <gx1> ^max >= <gx2> ^com <gy1> ^layer <lay>) + (congestion ^direction row ^coordinate <gy1> ^como <gy3>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy3> ^max >= <gy3> ^com <gx1> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy3> ^layer <lay>) + --> + (modify <v> ^max <gy3> ^max-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn1> ^min <gy3> ^max <gy1> ^com <gx1> ^compo <gx2> ^commo <cmo> ^layer <lay>) + (modify <ff> ^grid-y <gy3> ^can-chng-layer nil ^came-from north) +) + +(p p36 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-right-pins 1 ^no-of-left-pins 1) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + { <v> (horizontal ^net-name nil ^min <gx2> ^max > <gx2> ^com <gy2> ^layer <lay> ^commo <cmo> ^compo <gy1> ^min-net <garb2>) } + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com <gx2> ^layer <lay>) + (congestion ^direction col ^coordinate <gx3> ^como <gx2>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx3> ^max >= <gx3> ^com <gy2> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx3> ^layer <lay>) + --> + (modify <v> ^min <gx3> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn2> ^min <gx2> ^max <gx3> ^com <gy2> ^compo <gy1> ^commo <cmo> ^layer <lay>) + (modify <ff> ^grid-x <gx3> ^can-chng-layer nil ^came-from west) +) + +(p p37 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-right-pins 1 ^no-of-left-pins 1) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + { <v> (horizontal ^net-name nil ^min < <gx1> ^max <gx1> ^com <gy1> ^layer <lay> ^commo <gy2> ^compo <cpo> ^min-net <garb2>) } + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com <gx1> ^layer <lay>) + (congestion ^direction col ^coordinate <gx1> ^como <gx3>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx3> ^max >= <gx3> ^com <gy1> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx3> ^layer <lay>) + --> + (modify <v> ^max <gx3> ^max-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn1> ^min <gx3> ^max <gx1> ^com <gy1> ^compo <cpo> ^commo <gy2> ^layer <lay>) + (modify <ff> ^grid-x <gx3> ^can-chng-layer nil ^came-from east) +) + +(p p38 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-right-pins 1 ^no-of-left-pins 1) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + { <v> (horizontal ^net-name nil ^min < <gx2> ^max <gx2> ^com <gy2> ^layer <lay> ^commo <cmo> ^compo <gx1> ^min-net <garb2>) } + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com <gx2> ^layer <lay>) + (congestion ^direction col ^coordinate <gx2> ^como <gx3>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx3> ^max >= <gx3> ^com <gy2> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx3> ^layer <lay>) + --> + (modify <v> ^max <gx3> ^max-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn2> ^min <gx3> ^max <gx2> ^com <gy2> ^compo <gy1> ^commo <cmo> ^layer <lay>) + (modify <ff> ^grid-x <gx3> ^can-chng-layer nil ^came-from east) +) + +(p p39 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-right-pins 1 ^no-of-left-pins 1) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + { <v> (horizontal ^net-name nil ^min <gx1> ^max > <gx1> ^com <gy1> ^layer <lay> ^commo <gy2> ^compo <cpo> ^min-net <garb2>) } + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com <gx1> ^layer <lay>) + (congestion ^direction col ^coordinate <gx3> ^como <gx1>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx3> ^max >= <gx3> ^com <gy1> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx3> ^layer <lay>) + --> + (modify <v> ^min <gx3> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn1> ^min <gx1> ^max <gx3> ^com <gy1> ^compo <cpo> ^commo <gy2> ^layer <lay>) + (modify <ff> ^grid-x <gx3> ^can-chng-layer nil ^came-from west) +) + +(p p40 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cpo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cmo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p41 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cpo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cmo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p42 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cmo> ^layer <lay>) + (last-row <gy>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p43 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cmo> ^layer <lay>) + (last-row <gy>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p44 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cpo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay> ^commo 0) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p45 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cpo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay> ^commo 0) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p46 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cpo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <h1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cmo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <vmax2> ^max-net nil) +) + +(p p47 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cpo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cmo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p48 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cmo> ^layer <lay>) + (last-col <gx>) + --> + (modify <v1> ^max <vmax2> ^max-net nil) +) + +(p p49 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cmo> ^layer <lay>) + (last-col <gx>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p50 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cpo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay> ^commo 0) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^max <vmax2> ^max-net nil) +) + +(p p51 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cpo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay> ^commo 0) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p52 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <gx> ^max <ppgarb> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cpo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cmo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p53 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gx> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cpo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cmo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p54 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <gx> ^max <ppgarb> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cmo> ^layer <lay>) + (last-row <gy>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p55 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gx> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cmo> ^layer <lay>) + (last-row <gy>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p56 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <gx> ^max <ppgarb> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cpo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay> ^commo 0) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p57 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gx> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cpo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay> ^commo 0) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p58 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <gy> ^max <ppgarb> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cpo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <h1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cmo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <vmax2> ^max-net nil) +) + +(p p59 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gy> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cpo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cmo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p60 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <gy> ^max <ppgarb> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cmo> ^layer <lay>) + (last-col <gx>) + --> + (modify <v1> ^max <vmax2> ^max-net nil) +) + +(p p61 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gy> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cmo> ^layer <lay>) + (last-col <gx>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p62 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <gy> ^max <ppgarb> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cpo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay> ^commo 0) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^max <vmax2> ^max-net nil) +) + +(p p63 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gy> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cpo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay> ^commo 0) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p64 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max { <hmax> > <vcom> } ^com <vmax> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min < <vmax> ^max >= <vmax> ^com <vcmo> ^layer <lay> ^compo <vcom> ^commo <garb1>) + (vertical ^net-name { <nn2> <> <nn1> <> nil } ^min < <vmax> ^max >= <vmax> ^com <vcpo> ^layer <lay> ^compo <garb2> ^commo <vcom>) + (horizontal ^net-name nil ^min < <vcom> ^max > <vcom> ^com <hcmo> ^layer <lay>) + - (vertical ^status nil ^min <vmax> ^max > <vmax> ^com <vcom>) + - (horizontal ^status nil ^min { <temp> <= <vcom> } ^max { > <temp> >= <vcom> } ^com <vmax> ^layer <> <lay>) + --> + (modify <v> ^max <hcmo> ^max-net nil) + (make (substr <h> 1 inf) ^max <vcmo> ^max-net <nn1>) + (modify <h> ^min <vcpo> ^min-net <nn2>) +) + +(p p65 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max { <hmax> > <vcom> } ^com <vmin> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min <= <vmin> ^max > <vmin> ^com <vcmo> ^layer <lay> ^compo <vcom> ^commo <garb1>) + (vertical ^net-name { <nn2> <> <nn1> <> nil } ^min <= <vmin> ^max > <vmin> ^com <vcpo> ^layer <lay> ^compo <garb2> ^commo <vcom>) + (horizontal ^net-name nil ^min < <vcom> ^max > <vcom> ^com <hcpo> ^layer <lay>) + - (vertical ^status nil ^min < <vmin> ^max <vmin> ^com <vcom>) + - (horizontal ^status nil ^min { <temp> <= <vcom> } ^max { > <temp> >= <vcom> } ^com <vmin> ^layer <> <lay>) + --> + (modify <v> ^min <hcpo> ^min-net nil) + (make (substr <h> 1 inf) ^max <vcmo> ^max-net <nn1>) + (modify <h> ^min <vcpo> ^min-net <nn2>) +) + +(p p66 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min { <vmin> < <hcom> } ^max { <vmax> > <hcom> } ^com <hmax> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min < <hmax> ^max >= <hmax> ^com <hcmo> ^layer <lay> ^compo <hcom> ^commo <garb1>) + (horizontal ^net-name { <nn2> <> <nn1> <> nil } ^min < <hmax> ^max >= <hmax> ^com <hcpo> ^layer <lay> ^compo <garb2> ^commo <hcom>) + (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com <vcmo> ^layer <lay>) + - (horizontal ^status nil ^min <hmax> ^max > <hmax> ^com <hcom>) + - (vertical ^status nil ^min { <temp> <= <hcom> } ^max { > <temp> >= <hcom> } ^com <hmax> ^layer <> <lay>) + --> + (modify <h> ^max <vcmo> ^max-net nil) + (make (substr <v> 1 inf) ^max <hcmo> ^max-net <nn1>) + (modify <v> ^min <hcpo> ^min-net <nn2>) +) + +(p p67 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min { <vmin> < <hcom> } ^max { <vmax> > <hcom> } ^com <hmin> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min <= <hmin> ^max > <hmin> ^com <hcmo> ^layer <lay> ^compo <hcom> ^commo <garb1>) + (horizontal ^net-name { <nn2> <> <nn1> <> nil } ^min <= <hmin> ^max > <hmin> ^com <hcpo> ^layer <lay> ^compo <garb2> ^commo <hcom>) + (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com <vcpo> ^layer <lay>) + - (horizontal ^status nil ^min < <hmin> ^max <hmin> ^com <hcom>) + - (vertical ^status nil ^min { <temp> <= <hcom> } ^max { > <temp> >= <hcom> } ^com <hmin> ^layer <> <lay>) + --> + (modify <h> ^min <vcpo> ^min-net nil) + (make (substr <v> 1 inf) ^max <hcmo> ^max-net <nn1>) + (modify <v> ^min <hcpo> ^min-net <nn2>) +) + +(p p68 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max <vcom> ^com <vmax> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min < <vmax> ^max >= <vmax> ^com <vcmo> ^layer <lay> ^compo <vcom> ^commo <garb1>) + (horizontal ^net-name nil ^min < <vcom> ^max >= <vcom> ^com <hcmo> ^layer <lay>) + - (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <vcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min <vcom> ^max > <vcom> ^com <vmax> ^layer <> <lay>) + --> + (modify <h> ^max <vcmo> ^max-net <nn1>) +) + +(p p69 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min <vcom> ^max { <hmax> > <vcom> } ^com <vmax> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min < <vmax> ^max >= <vmax> ^com <vcpo> ^layer <lay> ^compo <garb1> ^commo <vcom>) + (horizontal ^net-name nil ^min <= <vcom> ^max > <vcom> ^com <hcmo> ^layer <lay>) + - (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <vcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <vcom> ^max <vcom> ^com <vmax> ^layer <> <lay>) + --> + (modify <h> ^min <vcpo> ^min-net <nn1>) +) + +(p p70 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max <vcom> ^com <vmin> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min <= <vmin> ^max > <vmin> ^com <vcmo> ^layer <lay> ^compo <vcom> ^commo <garb1>) + (horizontal ^net-name nil ^min < <vcom> ^max >= <vcom> ^com <hcpo> ^layer <lay>) + - (vertical ^net-name nil ^min < <vmin> ^max <vmin> ^com <vcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min <vcom> ^max > <vcom> ^com <vmin> ^layer <> <lay>) + --> + (modify <h> ^max <vcmo> ^max-net <nn1>) +) + +(p p71 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min <vcom> ^max { <hmax> > <vcom> } ^com <vmin> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min <= <vmin> ^max > <vmin> ^com <vcpo> ^layer <lay> ^compo <garb1> ^commo <vcom>) + (horizontal ^net-name nil ^min <= <vcom> ^max > <vcom> ^com <hcpo> ^layer <lay>) + - (vertical ^net-name nil ^min < <vmin> ^max <vmin> ^com <vcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <vcom> ^max <vcom> ^com <vmin> ^layer <> <lay>) + --> + (modify <h> ^min <vcpo> ^min-net <nn1>) +) + +(p p72 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min <hcom> ^max { <vmax> > <hcom> } ^com <hmax> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min < <hmax> ^max >= <hmax> ^com <hcpo> ^layer <lay> ^compo <garb1> ^commo <hcom>) + (vertical ^net-name nil ^min <= <hcom> ^max > <hcom> ^com <vcmo> ^layer <lay>) + - (horizontal ^net-name nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com <hmax> ^layer <> <lay>) + --> + (modify <v> ^min <hcpo> ^min-net <nn1>) +) + +(p p73 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min { <vmin> < <hcom> } ^max <hcom> ^com <hmax> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min < <hmax> ^max >= <hmax> ^com <hcmo> ^layer <lay> ^compo <hcom> ^commo <garb1>) + (vertical ^net-name nil ^min < <hcom> ^max >= <hcom> ^com <vcmo> ^layer <lay>) + - (horizontal ^net-name nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com <hmax> ^layer <> <lay>) + --> + (modify <v> ^max <hcmo> ^max-net <nn1>) +) + +(p p74 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min <hcom> ^max { <vmax> > <hcom> } ^com <hmin> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min <= <hmin> ^max > <hmin> ^com <hcpo> ^layer <lay> ^compo <garb1> ^commo <hcom>) + (vertical ^net-name nil ^min <= <hcom> ^max > <hcom> ^com <vcpo> ^layer <lay>) + - (horizontal ^net-name nil ^min < <hmin> ^max <hmin> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com <hmin> ^layer <> <lay>) + --> + (modify <v> ^min <hcpo> ^min-net <nn1>) +) + +(p p75 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min { <vmin> < <hcom> } ^max <hcom> ^com <hmin> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min <= <hmin> ^max > <hmin> ^com <hcmo> ^layer <lay> ^compo <hcom> ^commo <garb1>) + (vertical ^net-name nil ^min < <hcom> ^max >= <hcom> ^com <vcpo> ^layer <lay>) + - (horizontal ^net-name nil ^min < <hmin> ^max <hmin> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com <hmin> ^layer <> <lay>) + --> + (modify <v> ^max <hcmo> ^max-net <nn1>) +) + +(p p76 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay>) + (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <vcom> ^layer <vlay>) + (horizontal ^net-name { <nn2> <> <nn1> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer { <hlay> <> <vlay> } ^compo <hcpo> ^commo <vmax>) + - (horizontal ^status nil ^min <= <vcom> ^max >= <vcom> ^com <vmax>) + { <v> (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <vcom> ^layer <hlay>) } + --> + (modify <v> ^min <hcom> ^min-net <nn2>) +) + +(p p77 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay>) + (vertical ^net-name nil ^min <garb1> ^max { <vmin> > <garb1> } ^com <vcom> ^layer <vlay>) + (horizontal ^net-name { <nn2> <> <nn1> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer { <hlay> <> <vlay> } ^compo <vmin> ^commo <hcmo>) + - (horizontal ^status nil ^min <= <vcom> ^max >= <vcom> ^com <vmin>) + { <v> (vertical ^net-name nil ^min <garb2> ^max { <vmin> > <garb2> } ^com <vcom> ^layer <hlay>) } + --> + (modify <v> ^max <hcom> ^max-net <nn2>) +) + +(p p78 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay>) + (horizontal ^net-name nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <hlay>) + (vertical ^net-name { <nn2> <> <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer { <vlay> <> <hlay> } ^compo <vcpo> ^commo <hmax>) + - (vertical ^status nil ^min <= <hcom> ^max >= <hcom> ^com <hmax>) + { <h> (horizontal ^net-name nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <vlay>) } + --> + (modify <h> ^min <vcom> ^min-net <nn2>) +) + +(p p79 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay>) + (horizontal ^net-name nil ^min <garb1> ^max { <hmin> > <garb1> } ^com <hcom> ^layer <hlay>) + (vertical ^net-name { <nn2> <> <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer { <vlay> <> <hlay> } ^compo <hmin> ^commo <vcmo>) + - (vertical ^status nil ^min <= <hcom> ^max >= <hcom> ^com <hmin>) + { <h> (horizontal ^net-name nil ^min <garb2> ^max { <hmin> > <garb2> } ^com <hcom> ^layer <vlay>) } + --> + (modify <h> ^max <vcom> ^max-net <nn2>) +) + +(p p80 + (context ^present propagate-constraint) + (last-col <lc>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> <= 1 } ^max <vmax> ^com <vcom> ^layer <vlay> ^pin-name <pn> ^commo <vcmo>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <vcom> ^max { <hmax> >= <lc> } ^com <vmax> ^layer <hlay>) + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max <vcom> ^com { <hcom> >= <vmin> <= <vmax> } ^layer <lay>) } + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com { > <hcom> <= <vmax> }) + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com { < <hcom> >= <vmin> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com { > <hcom> <= <vmax> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com { < <hcom> >= <vmin> }) + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com <hcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name <nn> ^min <= <vmax> ^max >= <vmax> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name nil ^min <= <vmax> ^max >= <vmax> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name nil ^min <= <vmax> ^max >= <vmax> ^com <vcom>) + - (vertical ^net-name <nn> ^min <vmax> ^max > <vmax> ^com <vcom>) + - (vertical ^net-name nil ^min <= <vmin> ^max >= <vmin> ^com <vcom>) + - (vertical ^net-name <nn> ^min < <vmin> ^max <vmin> ^com <vcom>) + --> + (make (substr <h> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <vcmo>) + (modify <h> ^max <vcmo> ^max-net <nn>) + (make ff ^grid-x <vcmo> ^grid-y <hcom> ^grid-layer <lay> ^net-name <nn> ^pin-name <pn> ^came-from east) +) + +(p p81 + (context ^present propagate-constraint) + (last-row <lr>) + (last-col <lc>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max { <vmax> >= <lr> } ^com <vcom> ^layer <vlay> ^pin-name <pn> ^commo <vcmo>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <vcom> ^max { <hmax> >= <lc> } ^com <vmin> ^layer <hlay>) + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max <vcom> ^com { <hcom> >= <vmin> <= <vmax> } ^layer <lay>) } + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com { > <hcom> <= <vmax> }) + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com { < <hcom> >= <vmin> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com { > <hcom> <= <vmax> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com { < <hcom> >= <vmin> }) + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com <hcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name <nn> ^min <= <vmin> ^max >= <vmin> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name nil ^min <= <vmin> ^max >= <vmin> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name nil ^min <= <vmin> ^max >= <vmin> ^com <vcom>) + - (vertical ^net-name <nn> ^min < <vmin> ^max <vmin> ^com <vcom>) + - (vertical ^net-name nil ^min <= <vmax> ^max >= <vmax> ^com <vcom>) + - (vertical ^net-name <nn> ^min <vmax> ^max > <vmax> ^com <vcom>) + --> + (make (substr <h> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <vcmo>) + (modify <h> ^max <vcmo> ^max-net <nn>) + (make ff ^grid-x <vcmo> ^grid-y <hcom> ^grid-layer <lay> ^net-name <nn> ^pin-name <pn> ^came-from east) +) + +(p p82 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay> ^pin-name <pn> ^commo <hcmo>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <hcom> ^max <vmax1> ^com <hmin> ^layer <vlay1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <hcom> ^max <vmax2> ^com <hmax> ^layer <vlay2>) + { <v> (vertical ^net-name nil ^min { <vmin> < <hcom> } ^max <hcom> ^com { <vcom> >= <hmin> <= <hmax> } ^layer <lay>) } + - (vertical ^net-name <nn> ^min < <hcom> ^max >= <hcom> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name <nn> ^min < <hcom> ^max >= <hcom> ^com { < <vcom> >= <hmin> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <hcom> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <hcom> ^com { < <vcom> >= <hmin> }) + - (vertical ^net-name <nn> ^min < <hcom> ^max >= <hcom> ^com <vcom> ^layer <> <lay>) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <> <lay>) + - (horizontal ^net-name <nn> ^min <= <hmax> ^max >= <hmax> ^com { > <hcom> <= <vmax2> }) + - (horizontal ^net-name <nn> ^min <= <hmin> ^max >= <hmin> ^com { > <hcom> <= <vmax1> }) + - (horizontal ^net-name nil ^min <= <hmax> ^max >= <hmax> ^com { > <hcom> <= <vmax2> }) + - (horizontal ^net-name nil ^min <= <hmin> ^max >= <hmin> ^com { > <hcom> <= <vmax1> }) + - (horizontal ^net-name nil ^min <= <hmax> ^max >= <hmax> ^com <hcom>) + - (horizontal ^net-name <nn> ^min <hmax> ^max > <hmax> ^com <hcom>) + - (horizontal ^net-name nil ^min <= <hmin> ^max >= <hmin> ^com <hcom>) + - (horizontal ^net-name <nn> ^min < <hmin> ^max <hmin> ^com <hcom>) + --> + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <hcmo>) + (modify <v> ^max <hcmo> ^max-net <nn>) + (make ff ^grid-x <vcom> ^grid-y <hcmo> ^grid-layer <lay> ^net-name <nn> ^pin-name <pn> ^came-from north) +) + +(p p377 + (context ^present find-no-of-pins-on-a-row-col) + (horizontal ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gy> ^layer <lay> ^compo <egarb1> ^commo <egabr2>) + (ff ^net-name <nn> ^grid-x { <fx> >= <min> <= <max> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn1>) + (ff ^net-name <nn> ^grid-y <gy> ^pin-name { <pn2> <> <pn1> } ^grid-x { <gx> > <fx> <= <max> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <fx> ^max >= <gx> ^com <gy>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { >= <fx> <= <gx> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <fx> ^max >= <fx> ^com <gy> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col row ^coor <gy>) + --> + (make total ^net-name <nn> ^row-col row ^coor <gy> ^level-pins 1 ^total-pins <np> ^min-xy <fx> ^max-xy <gx> ^last-pin <pn1> ^last-xy <fx>) +) + +(p p378 + (context ^present find-no-of-pins-on-a-row-col) + (horizontal ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gy> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (ff ^net-name <nn> ^grid-x { <fx> >= <min> <= <max> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx> > <fx> <= <max> } ^pin-name { <pn2> <> <pn1> }) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^pin-name <> <pn1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <fx> ^max >= <gx> ^com <gy>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { >= <fx> <= <gx> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <fx> ^max >= <fx> ^com <gy> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col row ^coor <gy>) + --> + (make total ^net-name <nn> ^row-col row ^coor <gy> ^level-pins 1 ^total-pins <np> ^min-xy <fx> ^max-xy <gx> ^last-pin <pn1> ^last-xy <fx>) +) + +(p p379 + (context ^present find-no-of-pins-on-a-row-col) + (horizontal ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gy> ^layer <lay>) + (ff ^net-name <nn> ^grid-x { <fx> >= <min> <= <max> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx> < <fx> >= <min> } ^pin-name { <pn2> <> <pn1> }) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^pin-name <> <pn1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <fx> ^com <gy>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <= <fx> >= <gx> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <fx> ^max >= <fx> ^com <gy> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col row ^coor <gy>) + --> + (make total ^net-name <nn> ^row-col row ^coor <gy> ^level-pins 1 ^total-pins <np> ^min-xy <gx> ^max-xy <fx> ^last-pin <pn2> ^last-xy <gx>) +) + +(p p380 + (context ^present find-no-of-pins-on-a-row-col) + (vertical ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gx> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <fy> >= <min> <= <max> } ^grid-layer <garb1> ^pin-name <pn1>) + (ff ^net-name <nn> ^grid-x <gx> ^pin-name { <pn2> <> <pn1> } ^grid-y { <gy> > <fy> <= <max> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <fy> ^max >= <gy> ^com <gx>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <fy> <= <gy> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <fy> ^max >= <fy> ^com <gx> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col col ^coor <gx>) + --> + (make total ^net-name <nn> ^row-col col ^coor <gx> ^level-pins 1 ^total-pins <np> ^min-xy <fy> ^max-xy <gy> ^last-pin <pn1> ^last-xy <fy>) +) + +(p p381 + (context ^present find-no-of-pins-on-a-row-col) + (vertical ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gx> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <fy> >= <min> <= <max> } ^grid-layer <garb1> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy> > <fy> <= <max> } ^pin-name { <pn2> <> <pn1> }) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^pin-name <> <pn1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <fy> ^max >= <gy> ^com <gx>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <fy> <= <gy> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <fy> ^max >= <fy> ^com <gx> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col col ^coor <gx>) + --> + (make total ^net-name <nn> ^row-col col ^coor <gx> ^level-pins 1 ^total-pins <np> ^min-xy <fy> ^max-xy <gy> ^last-pin <pn1> ^last-xy <fy>) +) + +(p p382 + (context ^present find-no-of-pins-on-a-row-col) + (vertical ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gx> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <fy> >= <min> <= <max> } ^grid-layer <garb1> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy> < <fy> >= <min> } ^pin-name { <pn2> <> <pn1> }) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^pin-name <> <pn1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <fy> ^com <gx>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <gy> <= <fy> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <fy> ^max >= <fy> ^com <gx> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col col ^coor <gx>) + --> + (make total ^net-name <nn> ^row-col col ^coor <gx> ^level-pins 1 ^total-pins <np> ^min-xy <gy> ^max-xy <fy> ^last-pin <pn2> ^last-xy <gy>) +) + +(p p383 + (context ^present find-no-of-pins-on-a-row-col) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <gy> ^grid-layer <garb2> ^pin-name <pn>) + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <np> ^no-of-bottom-pins <garb3>) + - (ff ^net-name <nn> ^grid-y <= <gy> ^pin-name <> <pn>) + - (total ^net-name <nn>) + --> + (make total ^net-name <nn> ^row-col row ^coor <gy> ^level-pins <np> ^total-pins <np>) +) + +(p p384 + (context ^present find-no-of-pins-on-a-row-col) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <gy> ^grid-layer <garb2> ^pin-name <pn>) + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <garb3> ^no-of-bottom-pins <np>) + - (ff ^net-name <nn> ^grid-y >= <gy> ^pin-name <> <pn>) + - (total ^net-name <nn>) + --> + (make total ^net-name <nn> ^row-col row ^coor <gy> ^level-pins <np> ^total-pins <np>) +) + +(p p385 + (context ^present find-no-of-pins-on-a-row-col) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <np> ^no-of-bottom-pins <garb2>) + - (total ^net-name <nn>) + (ff ^net-name <nn> ^grid-y <gy> ^pin-name <> <pn> ^grid-x { <fx> > <gx> }) + - (ff ^net-name <nn> ^grid-y < <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <fx> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <fx> ^com <gy>) + { <v1> (vertical ^net-name nil ^min { <min> < <gy> } ^max >= <gy> ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^min-net <mn>) } + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <gy> ^como <hcmo>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <hcmo> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify <v1> ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff1> ^grid-y <hcmo> ^can-chng-layer nil) + (make total ^net-name <nn> ^row-col row ^coor <hcmo> ^level-pins <np> ^total-pins <np>) +) + +(p p386 + (context ^present find-no-of-pins-on-a-row-col) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <garb2> ^no-of-bottom-pins <np>) + - (total ^net-name <nn>) + (ff ^net-name <nn> ^grid-y <gy> ^pin-name <> <pn> ^grid-x { <fx> > <gx> }) + - (ff ^net-name <nn> ^grid-y > <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <fx> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <fx> ^com <gy>) + { <v1> (vertical ^net-name nil ^min <= <gy> ^max { <max> > <gy> } ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <mn>) } + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <hcmo> ^como <gy>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <max> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <nn> ^max-net <mn>) + (modify <v1> ^max <gy> ^max-net <nn>) + (make vertical ^net-name <nn> ^min <gy> ^max <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff1> ^grid-y <hcmo> ^can-chng-layer nil) + (make total ^net-name <nn> ^row-col row ^coor <hcmo> ^level-pins <np> ^total-pins <np>) +) + +(p p387 + { <t1> (total ^net-name <nn> ^row-col row ^coor <y> ^level-pins <np> ^total-pins <np> ^min-xy nil ^max-xy nil) } + (pin ^net-name <nn> ^pin-x <px1>) + - (pin ^net-name <nn> ^pin-x < <px1>) + (pin ^net-name <nn> ^pin-x { <px2> > <px1> }) + - (pin ^net-name <nn> ^pin-x > <px2>) + --> + (modify <t1> ^min-xy <px1> ^max-xy <px2>) +) + +(p p388 + (context ^present find-no-of-pins-on-a-row-col) + --> + (make context ^previous find-no-of-pins-on-a-row-col) + (remove 1) +) + +(p p389 + (context ^previous find-no-of-pins-on-a-row-col) + (total) + --> + (remove 1) + (make context ^present modify-total) +) + +(p p390 + (context ^present delete-totals) + --> + (modify 1 ^present choose-between-nets-on-the-same-row-col) +) + +(p p391 + { <c1> (context ^present << choose-between-nets-on-the-same-row-col choose-between-nets-on-the-same-row-col-con >>) } + { <t1> (total ^net-name <nn> ^row-col { << row col >> <rc> } ^coor <xy> ^level-pins <cou> ^total-pins <garb1>) } + - (total ^net-name <> <nn> ^level-pins >= <cou>) + - (total ^net-name <nn> ^row-col <> <rc> ^level-pins >= <cou>) + --> + (remove <c1> <t1>) + (make change-priority) + (make tran-total <rc> <xy> (substr <t1> nets inf)) +) + +(p p392 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <garb1> ^row-col { << row col >> <garb2> } ^coor <garb3> ^level-pins <cou> ^total-pins <cou>) + { <t1> (total ^level-pins < <cou>) } + --> + (remove <t1>) +) + +(p p393 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <garb1> ^row-col { << row col >> <garb2> } ^coor <garb3> ^level-pins <cou> ^total-pins <garb4>) + { <t1> (total ^level-pins <cou1> ^total-pins { < <cou> <> <cou1> }) } + --> + (remove <t1>) +) + +(p p394 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn> ^row-col { << row col >> <rc> } ^coor <garb1> ^level-pins <cou>) + { <t1> (total ^net-name <nn> ^row-col <> <rc> ^level-pins <cou>) } + --> + (remove <t1>) +) + +(p p395 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn> ^row-col { << row col >> <rc> } ^coor <xy> ^level-pins <cou> ^total-pins <garb1>) + { <t1> (total ^net-name <nn> ^row-col <rc> ^coor <> <xy> ^level-pins <cou>) } + --> + (remove <t1>) +) + +(p p396 + { <c1> (context ^present << choose-between-nets-on-the-same-row-col choose-between-nets-on-the-same-row-col-con >>) } + { <t1> (total ^net-name <nn> ^row-col { << row col >> <rc> } ^coor <xy> ^level-pins <cou> ^total-pins <cou>) } + - (total ^net-name <> <nn> ^level-pins <cou> ^total-pins <cou>) + --> + (remove <c1> <t1>) + (make change-priority) + (make tran-total <rc> <xy> (substr <t1> nets inf)) +) + +(p p397 + { <t1> (tran-total <rc> <xy> { <nn> <> nil <> end } <min> <max>) } + --> + (write (crlf) |***** next net to be routed is| <nn> *****) + (make next-segment <nn> <rc> <xy> useless <min> <max>) + (remove <t1>) + (make tran-total <rc> <xy> (substr <t1> 7 inf)) +) + +(p p398 + { <t1> (tran-total <rc> <xy> nil) } + --> + (make dominant-layer) + (remove <t1>) + (make goal cleanup total-verti) + (make goal cleanup counted-verti) + (make goal cleanup total) + (make goal cleanup extend-ff-tried) +) + +(p p399 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn> ^row-col { << row col >> <garb1> } ^coor <garb2> ^level-pins <cou> ^total-pins <cou>) + { <t1> (total ^net-name <> <nn> ^level-pins <cou> ^total-pins > <cou>) } + --> + (remove <t1>) +) + +(p p400 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn> ^row-col { << row col >> <garb1> } ^coor <garb2> ^level-pins <cou> ^total-pins <cou1>) + { <t1> (total ^net-name <> <nn> ^level-pins <cou> ^total-pins > <cou1>) } + - (total ^net-name <garb3> ^row-col <garb4> ^coor <garb5> ^level-pins <cou2> ^total-pins <cou2>) + --> + (remove <t1>) +) + +(p p401 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <garb1> ^row-col <garb2> ^coor <garb3> ^level-pins <cou1> ^total-pins <cou2>) + { <t1> (total ^net-name <garb4> ^row-col <garb5> ^coor <garb6> ^level-pins < <cou1> ^total-pins < <cou2>) } + --> + (remove <t1>) +) + +(p p402 + (context ^present choose-between-nets-on-the-same-row-col) + --> + (modify 1 ^present choose-between-nets-on-the-same-row-col-con) +) + +(p p403 + (context ^present choose-between-nets-on-the-same-row-col-con) + { <t1> (total ^net-name <nn> ^row-col row ^level-pins <cou> ^total-pins <cou2> ^cong nil) } + (total ^net-name <> <nn> ^level-pins <cou> ^total-pins <cou2>) + (pin ^net-name <nn> ^pin-x <px1>) + - (pin ^net-name <nn> ^pin-x < <px1>) + (pin ^net-name <nn> ^pin-x { <px2> > <px1> }) + - (pin ^net-name <nn> ^pin-x > <px2>) + (congestion ^direction col ^coordinate { >= <px1> <= <px2> } ^no-of-nets <non>) + - (congestion ^direction col ^coordinate { >= <px1> <= <px2> } ^no-of-nets > <non>) + --> + (modify <t1> ^cong <non>) +) + +(p p404 + (context ^present choose-between-nets-on-the-same-row-col-con) + { <t1> (total ^net-name <nn> ^row-col col ^level-pins <cou> ^total-pins <cou2> ^cong nil) } + (total <> <nn> { } { } <cou> <cou2>) + (pin ^net-name <nn> ^pin-y <py1>) + - (pin ^net-name <nn> ^pin-y < <py1>) + (pin ^net-name <nn> ^pin-y { <py2> > <py1> }) + - (pin ^net-name <nn> ^pin-y > <py2>) + (congestion ^direction row ^coordinate { >= <py1> <= <py2> } ^no-of-nets <non>) + - (congestion ^direction row ^coordinate { >= <py1> <= <py2> } ^no-of-nets > <non>) + --> + (modify <t1> ^cong <non>) +) + +(p p405 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil } ^min-xy <min1> ^max-xy <max1>) + (total ^net-name <> <nn> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil } ^min-xy { <min2> > <max1> } ^max-xy <max2>) + { <t> (total ^net-name <nn1> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil } ^min-xy <= <max1> ^max-xy >= <min2>) } + --> + (remove <t>) +) + +(p p406 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil } ^min-xy <min1> ^max-xy <max1>) + { <t> (total ^net-name <> <nn> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil } ^min-xy >= <min1> ^max-xy <= <max1>) } + --> + (remove <t>) +) + +(p p407 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) + { <t> (total ^net-name { <nn1> <> <nn> } ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) } + (<< vertical-cycle horizontal-cycle >> <nn1>) + --> + (remove <t>) +) + +(p p408 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^row-col row ^coor <y> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) + { <t> (total ^net-name { <nn1> <> <nn> } ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) } + (pin ^net-name <nn1> ^pin-y { <py> < <y> } ^pin-channel-side << left right >>) + - (pin ^net-name <nn> ^pin-y { > <py> < <y> } ^pin-channel-side << left right >>) + --> + (remove <t>) +) + +(p p409 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^row-col row ^coor <y> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) + { <t> (total ^net-name { <nn1> <> <nn> } ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) } + (pin ^net-name <nn1> ^pin-y { <py> > <y> } ^pin-channel-side << left right >>) + - (pin ^net-name <nn> ^pin-y { > <y> < <py> } ^pin-channel-side << left right >>) + --> + (remove <t>) +) + +(p p410 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^level-pins <cou> ^total-pins <cou2> ^cong <non>) + - (total ^cong nil) + { <t> (total ^net-name <> <nn> ^level-pins <cou> ^total-pins <cou2> ^cong <= <non>) } + --> + (remove <t>) +) + +(p p411 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn1> ^row-col <rc1> ^coor <xy1> ^level-pins <cou> ^total-pins > <cou>) + { <t1> (total ^net-name <nn2> ^row-col { <rc2> <> <rc1> } ^coor <xy2> ^level-pins <cou> ^total-pins > <cou>) } + { <t2> (total ^net-name <> <nn2> ^row-col <rc2> ^coor <xy2> ^level-pins <cou> ^total-pins > <cou>) } + --> + (remove <t1> <t2>) +) + +(p p412 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn1> ^row-col <rc1> ^coor <xy1> ^level-pins <cou> ^total-pins > <cou>) + { <t1> (total ^net-name <nn2> ^row-col <rc2> ^coor { <xy2> <> <xy1> } ^level-pins <cou> ^total-pins > <cou>) } + { <t2> (total ^net-name <> <nn2> ^row-col <rc2> ^coor <xy2> ^level-pins <cou> ^total-pins > <cou>) } + --> + (remove <t1> <t2>) +) + +(p p413 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-bottom-pins { <np> > 1 } ^net-is-routed <> yes) + - (total-verti <nn> bottom) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side bottom) + --> + (make total-verti <nn> bottom 0 <np>) +) + +(p p414 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-bottom-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> bottom) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side bottom) + (constraint ^constraint-type << horizontal vertical >> ^net-name-1 <nn>) + --> + (make total-verti <nn> bottom 0 <np>) +) + +(p p415 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-bottom-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> bottom) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side bottom) + (constraint ^constraint-type << horizontal vertical >> ^net-name-2 <nn>) + --> + (make total-verti <nn> bottom 0 <np>) +) + +(p p416 + (context ^present find-no-of-vcg-hcg) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <garb1>) + (pin ^net-name <nn> ^pin-x <gx> ^pin-channel-side top ^pin-name <pn1>) + (net ^net-name { <nn1> <> <nn> } ^no-of-bottom-pins { <np> > 0 } ^net-is-routed <> yes) + (pin ^net-name <nn1> ^pin-x <gx> ^pin-channel-side bottom ^pin-name <pn2>) + - (total-verti <nn1> bottom) + - (constraint ^constraint-type vertical ^net-name-1 <nn> ^net-name-2 <nn1> ^pin-name-1 <pn1> ^pin-name-2 <pn2>) + --> + (make counted-verti <nn1> bottom <nn> <pn1> <pn2>) + (make total-verti <nn1> bottom 1 <np>) +) + +(p p417 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-left-pins { <np> > 1 } ^net-is-routed <> yes) + - (total-verti <nn> left) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side left) + --> + (make total-verti <nn> left 0 <np>) +) + +(p p418 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-left-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> left) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side left) + (constraint ^constraint-type << horizontal vertical >> ^net-name-1 <nn>) + --> + (make total-verti <nn> left 0 <np>) +) + +(p p419 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-left-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> left) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side left) + (constraint ^constraint-type << horizontal vertical >> ^net-name-2 <nn>) + --> + (make total-verti <nn> left 0 <np>) +) + +(p p420 + (context ^present find-no-of-vcg-hcg) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <gy> ^grid-layer <garb3> ^pin-name <garb2>) + (pin ^net-name <nn> ^pin-y <gy> ^pin-channel-side right ^pin-name <pn1>) + (net ^net-name { <nn1> <> <nn> } ^no-of-left-pins { <np> > 0 } ^net-is-routed <> yes) + (pin ^net-name <nn1> ^pin-y <gy> ^pin-channel-side left ^pin-name <pn2>) + - (total-verti <nn1> left) + - (constraint ^constraint-type horizontal ^net-name-1 <nn> ^net-name-2 <nn1> ^pin-name-1 <pn1> ^pin-name-2 <pn2>) + --> + (make counted-verti <nn1> left <nn> <pn1> <pn2>) + (make total-verti <nn1> left 1 <np>) +) + +(p p421 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-top-pins { <np> > 1 } ^net-is-routed <> yes) + - (total-verti <nn> top) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side top) + --> + (make total-verti <nn> top 0 <np>) +) + +(p p422 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-top-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> top) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side top) + (constraint ^constraint-type << horizontal vertical >> ^net-name-1 <nn>) + --> + (make total-verti <nn> top 0 <np>) +) + +(p p423 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-top-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> top) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side top) + (constraint ^constraint-type << horizontal vertical >> ^net-name-2 <nn>) + --> + (make total-verti <nn> top 0 <np>) +) + +(p p424 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-right-pins { <np> > 1 } ^net-is-routed <> yes) + - (total-verti <nn> right) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side right) + --> + (make total-verti <nn> right 0 <np>) +) + +(p p425 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-right-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> right) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side right) + (constraint ^constraint-type << horizontal vertical >> ^net-name-1 <nn>) + --> + (make total-verti <nn> right 0 <np>) +) + +(p p426 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-right-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> right) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side right) + (constraint ^constraint-type << horizontal vertical >> ^net-name-2 <nn>) + --> + (make total-verti <nn> right 0 <np>) +) + +(p p427 + (context ^present find-no-of-vcg-hcg) + (total-verti <nn> bottom <ntc>) + (constraint ^constraint-type vertical ^net-name-1 <tn> ^net-name-2 <nn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + - (counted-verti <nn> bottom <tn> <tpn> <bpn>) + --> + (make counted-verti <nn> bottom <tn> <tpn> <bpn>) + (modify 2 ^4 (compute <ntc> + 1)) +) + +(p p428 + (context ^present find-no-of-vcg-hcg) + (total-verti <nn> left <ntc>) + (constraint ^constraint-type horizontal ^net-name-1 <tn> ^net-name-2 <nn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + - (counted-verti <nn> left <tn> <tpn> <bpn>) + --> + (make counted-verti <nn> left <tn> <tpn> <bpn>) + (modify 2 ^4 (compute <ntc> + 1)) +) + +(p p429 + (context ^present find-no-of-vcg-hcg) + (total-verti <nn> top <ntc>) + (constraint ^constraint-type vertical ^net-name-1 <nn> ^net-name-2 <bn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + - (counted-verti <nn> top <bn> <tpn> <bpn>) + --> + (make counted-verti <nn> top <bn> <tpn> <bpn>) + (modify 2 ^4 (compute <ntc> + 1)) +) + +(p p430 + (context ^present find-no-of-vcg-hcg) + (total-verti <nn> right <ntc>) + (constraint ^constraint-type horizontal ^net-name-1 <nn> ^net-name-2 <bn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + - (counted-verti <nn> right <bn> <tpn> <bpn>) + --> + (make counted-verti <nn> right <bn> <tpn> <bpn>) + (modify 2 ^4 (compute <ntc> + 1)) +) + +(p p431 + (context ^present find-no-of-vcg-hcg) + --> + (remove 1) + (make context ^previous find-no-of-vcg-hcg) +) + +(p p432 + (context ^previous find-no-of-vcg-hcg) + (total-verti) + --> + (remove 1) + (make context ^present choose-between-total-verti) + (make context ^present choose-between-total-verti-0) +) + +(p p433 + (context ^present choose-between-total-verti) + - (total-verti ^4 0) + { <t> (total-verti <nn> bottom <garb> > 1) } + - (ff ^net-name <nn> ^came-from south) + --> + (remove <t>) +) + +(p p434 + (context ^present choose-between-total-verti) + - (total-verti ^4 0) + { <t> (total-verti <nn> top <garb> > 1) } + - (ff ^net-name <nn> ^came-from north) + --> + (remove <t>) +) + +(p p435 + (context ^present choose-between-total-verti) + - (total-verti ^4 0) + { <t> (total-verti <nn> left <garb> > 1) } + - (ff ^net-name <nn> ^came-from west) + --> + (remove <t>) +) + +(p p436 + (context ^present choose-between-total-verti) + - (total-verti ^4 0) + { <t> (total-verti <nn> right <garb> > 1) } + - (ff ^net-name <nn> ^came-from east) + --> + (remove <t>) +) + +(p p437 + (context ^present choose-between-total-verti) + --> + (modify 1 ^present extend-total-verti) +) + +(p p438 + (context ^present choose-between-total-verti) + (total-verti ^4 > 0) + (total-verti ^4 0) + --> + (remove 3) +) + +(p p439 + (context ^present choose-between-total-verti) + (total-verti <nn> { << top bottom >> <tb> } > 0) + (total-verti <nn> { << top bottom >> <> <tb> } 0) + --> + (remove 3) +) + +(p p440 + (context ^present choose-between-total-verti) + (total-verti <nn> { << left right >> <tb> } > 0) + (total-verti <nn> { << left right >> <> <tb> } 0) + --> + (remove 3) +) + +(p p441 + (context ^present choose-between-total-verti-0) + (total-verti <nn> { << top bottom >> <tb> } > 0) + (total-verti <nn> { << top bottom >> <> <tb> } > 0) + --> + (remove 2 3) +) + +(p p442 + (context ^present choose-between-total-verti-0) + (total-verti <nn> { << left right >> <tb> } > 0) + (total-verti <nn> { << left right >> <> <tb> } > 0) + --> + (remove 2 3) +) + +(p p443 + (context ^present choose-between-total-verti-0) + --> + (remove 1) +) + +(p p444 + (context ^present extend-total-verti) + (total-verti <nn> bottom ^5 > 1) + - (total-verti ^5 1) + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) + - (ff ^net-name <nn> ^grid-y < <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy> ^com <gx>) + (vertical ^net-name nil ^min { <min> <= <gy> } ^max { > <min> > <gy> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + (congestion ^direction row ^coordinate <como> ^como <gy>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <como> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <como> ^max >= <como> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^min <min> ^max <gy> ^min-net <mn> ^max-net <nn> ^commo <vcmo> ^compo <vcpo> ^com <gx> ^layer <lay>) + (modify 4 ^min <como> ^min-net <nn>) + (make vertical ^net-name <nn> ^min <gy> ^max <como> ^layer <lay> ^commo <vcmo> ^compo <vcpo> ^pin-name <pn> ^com <gx>) + (modify 3 ^grid-y <como> ^can-chng-layer nil) + (remove 2) +) + +(p p445 + (context ^present extend-total-verti) + (total-verti <nn> left ^5 > 1) + - (total-verti ^5 1) + (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) + - (ff ^net-name <nn> ^grid-x < <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max > <gx> ^com <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx> } ^max { > <min> > <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + (congestion ^direction col ^coordinate <como> ^como <gx>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <como> ^max >= <como> ^com <gy> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <como> ^layer <lay>) + --> + (make horizontal ^net-name nil ^min <min> ^max <gx> ^min-net <mn> ^max-net <nn> ^commo <hcmo> ^compo <hcpo> ^com <gy> ^layer <lay>) + (modify 4 ^min <como> ^min-net <nn>) + (make horizontal ^net-name <nn> ^min <gx> ^max <como> ^layer <lay> ^commo <hcmo> ^compo <hcpo> ^pin-name <pn> ^com <gy>) + (modify 3 ^grid-x <como> ^can-chng-layer nil) + (remove 2) +) + +(p p446 + (context ^present extend-total-verti) + (total-verti <nn> top ^5 > 1) + - (total-verti ^5 1) + (ff ^came-from north ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) + - (ff ^net-name <nn> ^grid-y > <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy> ^com <gx>) + (vertical ^net-name nil ^max { <max> >= <gy> } ^min { < <max> < <gy> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^max-net <mn>) + (congestion ^direction row ^coordinate <gy> ^como <como>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <como> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <como> ^max >= <como> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^min <gy> ^max <max> ^max-net <mn> ^min-net <nn> ^commo <vcmo> ^compo <vcpo> ^com <gx> ^layer <lay>) + (modify 4 ^max <como> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <como> ^layer <lay> ^commo <vcmo> ^compo <vcpo> ^pin-name <pn> ^com <gx>) + (modify 3 ^grid-y <como> ^can-chng-layer nil) + (remove 2) +) + +(p p447 + (context ^present extend-total-verti) + (total-verti <nn> right ^5 > 1) + - (total-verti ^5 1) + (ff ^came-from east ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) + - (ff ^net-name <nn> ^grid-x > <gx>) + - (horizontal ^net-name { <nn> <> nil } ^min < <gx> ^max >= <gx> ^status nil ^com <gy>) + (horizontal ^net-name nil ^max { <max> >= <gx> } ^min { < <max> < <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^max-net <mn>) + (congestion ^direction col ^coordinate <gx> ^como <como>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <como> ^max >= <como> ^com <gy> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <como> ^layer <lay>) + --> + (make horizontal ^net-name nil ^min <gx> ^max <max> ^max-net <mn> ^min-net <nn> ^commo <hcmo> ^compo <hcpo> ^com <gy> ^layer <lay>) + (modify 4 ^max <como> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx> ^min <como> ^layer <lay> ^commo <hcmo> ^compo <hcpo> ^pin-name <pn> ^com <gy>) + (modify 3 ^grid-x <como> ^can-chng-layer nil) + (remove 2) +) + +(p p448 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> bottom ^5 1) } + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> > <gy> } ^com { <vcom> < <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + - (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmin>) + { <c6> (vertical ^net-name nil ^min <vvmin> ^max { <vmin> > <vvmin> } ^com <vcom> ^layer <lay> ^compo <garb1> ^commo <garb2>) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { > <hmin> >= <gx> } ^com { <hcom> >= <vvmin> < <vmin> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com { >= <vvmin> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <vcom> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin> > <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c6> ^max <hcom> ^max-net <nn>) + (modify <c4> ^min <hcom>) + (make pull-ff north <nn> <gx> <gy> <gx> <hcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from north) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p449 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> bottom ^5 1) } + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> > <gy> } ^com { <vcom> < <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + { <c5> (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmin> ^grid-layer <garb1> ^pin-name <garb2>) } + { <c7> (vertical ^net-name nil ^min <vvmin> ^max { <vmin> > <vvmin> } ^com <vcom> ^layer <lay> ^compo <garb3> ^commo <garb4>) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { > <hmin> >= <gx> } ^com { <hcom> >= <vvmin> < <vmin> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com { >= <vvmin> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <vcom> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin> > <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c7> ^max <hcom> ^max-net <nn>) + (modify <c4> ^min <hcom>) + (make pull-ff north <nn> <gx> <gy> <gx> <hcom>) + (modify <c5> ^grid-y <hcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p450 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> bottom ^5 1) } + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> > <gy> } ^com { <vcom> < <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + { <c6> (vertical ^net-name nil ^min <vvmin> ^max { <vmin> > <vvmin> } ^com <vcom> ^layer <lay> ^compo <garb1> ^commo <garb2>) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { > <hmin> >= <gx> } ^com { <hcom> >= <vvmin> < <vmin> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com { >= <vvmin> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <vcom> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin> > <hcom> }) + { <c41> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin1> > <gy> } ^com { <vcom1> > <gx> } ^layer <lay> ^pin-name <pn1>) } + - (vertical-s ^net-name <> <nn> ^com <vcom1>) + { <c61> (vertical ^net-name nil ^min <vvmin1> ^max { <vmin1> > <vvmin1> } ^com <vcom1> ^layer <lay>) } + (horizontal ^net-name nil ^min { <hmin1> <= <gx> } ^max { > <hmin1> >= <vcom1> } ^com { <hcom1> >= <vvmin1> < <vmin1> <= <hcom> }) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom1> ^com { >= <vvmin1> < <hcom1> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <gx> < <vcom1> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin1> > <hcom1> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom1> ^max >= <vcom1> ^com <hcom1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom1> ^max >= <hcom1> ^com <vcom> ^layer <lay>) + --> + (modify <c61> ^max <hcom1> ^max-net <nn>) + (modify <c41> ^min <hcom1>) + (make pull-ff north <nn> <gx> <gy> <gx> <hcom1>) + (make ff ^net-name <nn> ^pin-name <pn1> ^grid-layer <lay> ^grid-x <vcom1> ^grid-y <hcom1> ^came-from north) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p451 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> bottom ^5 1) } + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> > <gy> } ^com { <vcom> > <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + - (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmin>) + { <c6> (vertical ^net-name nil ^min <vvmin> ^max { <vmin> > <vvmin> } ^com <vcom> ^layer <lay>) } + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom> } ^com { <hcom> >= <vvmin> < <vmin> }) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com { >= <vvmin> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <gx> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin> > <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c6> ^max <hcom> ^max-net <nn>) + (modify <c4> ^min <hcom>) + (make pull-ff north <nn> <gx> <gy> <gx> <hcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from north) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p452 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> bottom ^5 1) } + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> > <gy> } ^com { <vcom> > <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + { <c5> (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmin> ^grid-layer <garb1> ^pin-name <garb2>) } + { <c7> (vertical ^net-name nil ^min <vvmin> ^max { <vmin> > <vvmin> } ^com <vcom> ^layer <lay>) } + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom> } ^com { <hcom> >= <vvmin> < <vmin> }) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com { >= <vvmin> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <gx> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin> > <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c7> ^max <hcom> ^max-net <nn>) + (modify <c4> ^min <hcom>) + (make pull-ff north <nn> <gx> <gy> <gx> <hcom>) + (modify <c5> ^grid-y <hcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p453 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> top ^5 1) } + (ff ^came-from north ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <vmax> < <gy> } ^com { <vcom> > <gx> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + - (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmax>) + { <c6> (vertical ^net-name nil ^min <vmax> ^max { <vvmax> > <vmax> } ^com <vcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom> } ^com { <hcom> <= <vvmax> > <vmax> }) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com { <= <vvmax> > <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <gx> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <vmax> < <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c6> ^min <hcom> ^min-net <nn>) + (modify <c4> ^max <hcom>) + (make pull-ff south <nn> <gx> <gy> <gx> <hcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from south) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p454 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> top ^5 1) } + (ff ^came-from north ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <vmax> < <gy> } ^com { <vcom> > <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + { <c5> (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmax> ^grid-layer <garb2> ^pin-name <garb3>) } + { <c7> (vertical ^net-name nil ^min <vmax> ^max { <vvmax> > <vmax> } ^com <vcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom> } ^com { <hcom> <= <vvmax> > <vmax> }) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com { <= <vvmax> > <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <gx> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <vmax> < <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c7> ^min <hcom> ^min-net <nn>) + (modify <c4> ^max <hcom>) + (make pull-ff south <nn> <gx> <gy> <gx> <hcom>) + (modify <c5> ^grid-y <hcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p455 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> top ^5 1) } + (ff ^came-from north ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <vmax> < <gy> } ^com { <vcom> < <gx> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + - (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmax>) + { <c6> (vertical ^net-name nil ^min <vmax> ^max { <vvmax> > <vmax> } ^com <vcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { > <hmin> >= <gx> } ^com { <hcom> <= <vvmax> > <vmax> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com { <= <vvmax> > <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <vcom> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <vmax> < <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c6> ^min <hcom> ^min-net <nn>) + (modify <c4> ^max <hcom>) + (make pull-ff south <nn> <gx> <gy> <gx> <hcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from south) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p456 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> top ^5 1) } + (ff ^came-from north ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <vmax> < <gy> } ^com { <vcom> < <gx> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + { <c5> (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmax> ^grid-layer <garb4> ^pin-name <garb5>) } + { <c7> (vertical ^net-name nil ^min <vmax> ^max { <vvmax> > <vmax> } ^com <vcom> ^layer <lay> ^compo <garb6> ^commo <garb7>) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { > <hmin> >= <gx> } ^com { <hcom> <= <vvmax> > <vmax> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com { <= <vvmax> > <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <vcom> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <vmax> < <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c7> ^min <hcom> ^min-net <nn>) + (modify <c4> ^max <hcom>) + (make pull-ff south <nn> <gx> <gy> <gx> <hcom>) + (modify <c5> ^grid-y <hcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p457 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> left ^5 1) } + (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <hmin> > <gx> } ^max <garb1> ^com { <hcom> < <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + - (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <hcom>) + { <c6> (horizontal ^net-name nil ^min <hhmin> ^max { <hmin> > <hhmin> } ^com <hcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (vertical ^net-name nil ^min { <vmin> <= <hcom> } ^max { > <vmin> >= <gy> } ^com { <vcom> >= <hhmin> < <hmin> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <gy> ^com { >= <hhmin> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { < <hmin> > <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c6> ^max <vcom> ^max-net <nn>) + (modify <c4> ^min <vcom>) + (make pull-ff east <nn> <gx> <gy> <gy> <vcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from east) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p458 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> left ^5 1) } + (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^net-name { <nn> <> nil } ^min { <hmin> > <gx> } ^max <garb1> ^com { <hcom> < <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + { <c5> (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <hcom> ^grid-layer <garb4> ^pin-name <garb5>) } + { <c7> (horizontal ^net-name nil ^min <hhmin> ^max { <hmin> > <hhmin> } ^com <hcom> ^layer <lay> ^compo <garb6> ^commo <garb7>) } + (vertical ^net-name nil ^min { <vmin> <= <hcom> } ^max { > <vmin> >= <gy> } ^com { <vcom> >= <hhmin> < <hmin> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <gy> ^com { >= <hhmin> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { < <hmin> > <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c7> ^max <vcom> ^max-net <nn>) + (modify <c4> ^min <vcom>) + (make pull-ff east <nn> <gx> <gy> <gy> <vcom>) + (modify <c5> ^grid-x <vcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p459 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> left ^5 1) } + (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^net-name { <nn> <> nil } ^min { <hmin> > <gx> } ^max <garb1> ^com { <hcom> > <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + - (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <hcom>) + { <c6> (horizontal ^net-name nil ^max <hmin> ^min { <hhmin> < <hmin> } ^com <hcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom> } ^com { <vcom> >= <hhmin> < <hmin> }) + - (vertical ^net-name nil ^min <= <gy> ^max >= <hcom> ^com { >= <hhmin> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <gy> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { < <hmin> > <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c6> ^max <vcom> ^max-net <nn>) + (modify <c4> ^min <vcom>) + (make pull-ff east <nn> <gx> <gy> <gy> <vcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from east) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p460 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> left ^5 1) } + (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <hmin> > <gx> } ^max <garb1> ^com { <hcom> > <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + { <c5> (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <hcom> ^grid-layer <garb4> ^pin-name <garb5>) } + { <c7> (horizontal ^net-name nil ^min <hhmin> ^max { <hmin> > <hhmin> } ^com <hcom> ^layer <lay> ^compo <garb6> ^commo <garb7>) } + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom> } ^com { <vcom> >= <hhmin> < <hmin> }) + - (vertical ^net-name nil ^min <= <gy> ^max >= <hcom> ^com { >= <hhmin> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <gy> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { < <hmin> > <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c7> ^max <vcom> ^max-net <nn>) + (modify <c4> ^min <vcom>) + (make pull-ff east <nn> <gx> <gy> <gy> <vcom>) + (modify <c5> ^grid-x <vcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p461 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> right ^5 1) } + (ff ^came-from east ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <hmax> < <gx> } ^com { <hcom> > <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + - (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <hcom>) + { <c6> (horizontal ^net-name nil ^min <hmax> ^max { <hhmax> > <hmax> } ^com <hcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom> } ^com { <vcom> <= <hhmax> > <hmax> }) + - (vertical ^net-name nil ^min <= <gy> ^max >= <hcom> ^com { <= <hhmax> > <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <gy> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <hmax> < <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c6> ^min <vcom> ^min-net <nn>) + (modify <c4> ^max <vcom>) + (make pull-ff west <nn> <gx> <gy> <gy> <vcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from west) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p462 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> right ^5 1) } + (ff ^came-from east ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <hmax> < <gx> } ^com { <hcom> > <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + { <c5> (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <hcom> ^grid-layer <garb4> ^pin-name <garb5>) } + { <c7> (horizontal ^net-name nil ^min <hmax> ^max { <hhmax> > <hmax> } ^com <hcom> ^layer <lay> ^compo <gabr6> ^commo <garb7>) } + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom> } ^com { <vcom> <= <hhmax> > <hmax> }) + - (vertical ^net-name nil ^min <= <gy> ^max >= <hcom> ^com { <= <hhmax> > <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <gy> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <hmax> < <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c7> ^min <vcom> ^min-net <nn>) + (modify <c4> ^max <vcom>) + (make pull-ff west <nn> <gx> <gy> <gy> <vcom>) + (modify <c5> ^grid-x <vcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p463 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> right ^5 1) } + (ff ^came-from east ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <hmax> < <gx> } ^com { <hcom> < <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + - (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <hcom>) + { <c6> (horizontal ^net-name nil ^min <hmax> ^max { <hhmax> > <hmax> } ^com <hcom> ^layer <lay> ^compo <garb4> ^commo <gabr5>) } + (vertical ^net-name nil ^min { <vmin> <= <hcom> } ^max { > <vmin> >= <gy> } ^com { <vcom> <= <hhmax> > <hmax> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <gy> ^com { <= <hhmax> > <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <hmax> < <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c6> ^min <vcom> ^min-net <nn>) + (modify <c4> ^max <vcom>) + (make pull-ff west <nn> <gx> <gy> <gy> <vcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from west) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p464 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> right ^5 1) } + (ff ^came-from east ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <hmax> < <gx> } ^com { <hcom> < <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + { <c5> (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <hcom> ^grid-layer <garb4> ^pin-name <garb5>) } + { <c7> (horizontal ^net-name nil ^min <hmax> ^max { <hhmax> > <hmax> } ^com <hcom> ^layer <lay> ^compo <garb6> ^commo <garb7>) } + (vertical ^net-name nil ^min { <vmin> <= <hcom> } ^max { > <vmin> >= <gy> } ^com { <vcom> <= <hhmax> > <hmax> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <gy> ^com { <= <hhmax> > <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <hmax> < <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c7> ^min <vcom> ^min-net <nn>) + (modify <c4> ^max <vcom>) + (make pull-ff west <nn> <gx> <gy> <gy> <vcom>) + (modify <c5> ^grid-x <vcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p465 + { <c1> (context ^present remove-total-verti-gt1) } + --> + (modify <c1> ^present find-no-of-pins-on-a-row-col) +) + +(p p466 + { <c1> (context ^present extend-total-verti) } + --> + (modify <c1> ^present remove-total-verti-gt1) +) + +(p p467 + (context ^present remove-total-verti-gt1) + (total-verti ^5 > 1) + { <t> (total-verti ^5 1) } + --> + (remove <t>) +) + +(p p468 + { <c1> (context ^present remove-total-verti-gt1) } + (total-verti ^5 > 1) + - (total-verti ^5 1) + --> + (make remove-all-total-vertis) + (modify <c1> ^present extend-total-verti) +) + +(p p469 + { <c1> (context ^present remove-total-verti-gt1) } + { <c> (remove-all-total-vertis) } + - (total-verti) + --> + (remove <c>) + (modify <c1> ^present propagate-constraint) +) + +(p p470 + { <c1> (context ^present remove-total-verti-gt1) } + { <c> (remove-all-total-vertis) } + --> + (remove <c>) + (modify <c1> ^present find-no-of-pins-on-a-row-col) +) + +(p p471 + { <c1> (context ^present << extend-total-verti remove-total-verti-gt1 >>) } + - (total-verti) + --> + (modify <c1> ^present propagate-constraint) +) + +(p p515 + { <c> (context ^previous find-no-of-pins-on-a-row-col) } + - (total) + { <p> (pull-ff north <nn> <gx> <gy1> <gx> <gy2>) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^came-from south ^pin-name <pn>) } + { <v> (vertical ^net-name nil ^min <gy1> ^max >= <gy2> ^com <gx> ^layer <lay>) } + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + --> + (remove <p> <c>) + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^max <gy2>) + (modify <v> ^min <gy2> ^min-net <nn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p516 + { <c> (context ^previous find-no-of-pins-on-a-row-col) } + - (total) + { <p> (pull-ff south <nn> <gx> <gy1> <gx> <gy2>) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^came-from north ^pin-name <pn>) } + { <v> (vertical ^net-name nil ^min <= <gy2> ^max <gy1> ^com <gx> ^layer <lay>) } + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + --> + (remove <p> <c>) + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <gy2>) + (modify <v> ^max <gy2> ^max-net <nn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p517 + { <c> (context ^previous find-no-of-pins-on-a-row-col) } + - (total) + { <p> (pull-ff east <nn> <gx1> <gy> <gx2> <gy>) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^came-from west ^pin-name <pn>) } + { <v> (horizontal ^net-name nil ^min <gx1> ^max >= <gx2> ^com <gy> ^layer <lay>) } + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove <p> <c>) + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^max <gx2>) + (modify <v> ^min <gx2> ^min-net <nn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p518 + { <c> (context ^previous find-no-of-pins-on-a-row-col) } + - (total) + { <p> (pull-ff west <nn> <gx1> <gy> <gx2> <gy>) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^came-from east ^pin-name <pn>) } + { <v> (horizontal ^net-name nil ^min <= <gx2> ^max <gx1> ^com <gy> ^layer <lay>) } + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove <p> <c>) + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <gx2>) + (modify <v> ^max <gx2> ^max-net <nn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p293 + (eliminate-total) + (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^min-xy <min1> ^max-xy <max1> ^level-pins <p1>) + { <t1> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^min-xy <min2> ^max-xy { <max2> > <max1> } ^level-pins < <p1>) } + - (total ^row-col <rc> ^coor <xy> ^max-xy < <min2>) + - (total ^row-col <rc> ^coor <xy> ^min-xy { > <max1> < <max2> }) + --> + (remove <t1>) +) + +(p p294 + (eliminate-total) + (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^min-xy <min1> ^max-xy <max1> ^level-pins <p1>) + { <t1> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^min-xy <min2> ^max-xy { <max2> < <max1> } ^level-pins < <p1>) } + - (total ^row-col <rc> ^coor <xy> ^max-xy < <min2>) + - (total ^row-col <rc> ^coor <xy> ^min-xy { > <max2> < <max1> }) + --> + (remove <t1>) +) + +(p p295 + (eliminate-total) + (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^min-xy <min1> ^max-xy <max1> ^level-pins <p1>) + { <t1> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^min-xy { <min2> < <min1> } ^max-xy <max2> ^level-pins < <p1>) } + - (total ^row-col <rc> ^coor <xy> ^min-xy > <max2>) + - (total ^row-col <rc> ^coor <xy> ^max-xy { > <min2> < <min1> }) + --> + (remove <t1>) +) + +(p p296 + (eliminate-total) + (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^min-xy <min1> ^max-xy <max1> ^level-pins <p1>) + { <t1> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^min-xy { <min2> > <min1> } ^max-xy <max2> ^level-pins < <p1>) } + - (total ^row-col <rc> ^coor <xy> ^min-xy > <max2>) + - (total ^row-col <rc> ^coor <xy> ^max-xy { > <min1> < <min2> }) + --> + (remove <t1>) +) + +(p p297 + (context ^present merge) + { <m> (merge-direction left) } + { <t1> (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^level-pins <lcou> ^total-pins <tcou> ^min-xy <min> ^max-xy <max>) } + - (rmerge) + - (total ^net-name <> <nn1> ^row-col <rc> ^coor <xy> ^max-xy < <max>) + (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^min-xy > <max>) + --> + (remove <m>) + (make merge-direction right) + (make lmerge <nn1> <rc> <xy> <min> <max> <lcou> <tcou> (substr <t1> nets inf)) +) + +(p p298 + (context ^present merge) + { <m> (merge-direction right) } + { <t1> (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^level-pins <lcou> ^total-pins <tcou> ^min-xy <min> ^max-xy <max>) } + - (lmerge) + - (total ^net-name <> <nn1> ^row-col <rc> ^coor <xy> ^min-xy > <min>) + (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^max-xy < <min>) + --> + (remove <m>) + (make merge-direction left) + (make rmerge <nn1> <rc> <xy> <min> <max> <lcou> <tcou> (substr <t1> nets inf)) +) + +(p p299 + { <c> (lmerge <nn1> <rc> <xy> <min> <max> <lcou> <tcou>) } + { <t2> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins <cou3> ^total-pins <cou4> ^min-xy { <min1> > <max> } ^max-xy <max1>) } + - (total ^row-col <rc> ^coor <xy> ^min-xy > <max> ^max-xy < <min1>) + - (place-holder <rc> <xy> > <max> < <min1>) + --> + (make total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^level-pins (compute <lcou> + <cou3>) ^total-pins (compute <tcou> + <cou4>) ^min-xy <min> ^max-xy <max1> ^nets (substr <c> 9 inf) (substr <t2> nets inf)) + (make delete-merged <nn2> <rc> <xy> <min1> <max1> (genatom)) +) + +(p p300 + { <c> (rmerge <nn1> <rc> <xy> <min> <max> <lcou> <tcou>) } + { <t2> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins <cou3> ^total-pins <cou4> ^min-xy <min1> ^max-xy { <max1> < <min> }) } + - (total ^row-col <rc> ^coor <xy> ^min-xy > <max1> ^max-xy < <min>) + - (place-holder <rc> <xy> > <max1> < <min>) + --> + (make total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins (compute <lcou> + <cou3>) ^total-pins (compute <tcou> + <cou4>) ^min-xy <min1> ^max-xy <max> ^nets (substr <c> 9 inf) (substr <t2> nets inf)) + (make rdelete-merged <nn2> <rc> <xy> <min1> <max1> (genatom)) +) + +(p p301 + { <d> (delete-merged <nn> <rc> <xy> <min> <max> <id>) } + (delete-merged <nn> <rc> <xy> <min> <max> <> <id>) + --> + (remove <d>) +) + +(p p302 + { <d> (rdelete-merged <nn> <rc> <xy> <min> <max> <id>) } + (rdelete-merged <nn> <rc> <xy> <min> <max> <> <id>) + --> + (remove <d>) +) + +(p p303 + (delete-merged <nn> <rc> <xy> <min> <max>) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max>) } + - (lmerge) + --> + (remove <t>) +) + +(p p304 + (rdelete-merged <nn> <rc> <xy> <min> <max>) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max>) } + - (rmerge) + --> + (remove <t>) +) + +(p p305 + { <d> (<< delete-merged rdelete-merged >>) } + - (<< lmerge rmerge >>) + --> + (remove <d>) +) + +(p p306 + (delete-merged <nn> <rc> <xy> <min> <max>) + { <t1> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max> ^level-pins <cou1> ^total-pins <cou2>) } + { <t2> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins <cou3> ^total-pins <cou4> ^min-xy <min1> ^max-xy { <max1> < <min> }) } + - (lmerge) + --> + (make place-holder <rc> <xy> <min> <max> (genatom)) + (make total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins (compute <cou1> + <cou3>) ^total-pins (compute <cou2> + <cou4>) ^min-xy <min1> ^max-xy <max> ^nets (substr <t1> nets inf) (substr <t2> nets inf)) +) + +(p p307 + (rdelete-merged <nn> <rc> <xy> <min> <max>) + { <t1> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max> ^level-pins <cou1> ^total-pins <cou2>) } + { <t2> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins <cou3> ^total-pins <cou4> ^min-xy { <min1> > <max> } ^max-xy <max1>) } + - (rmerge) + --> + (make place-holder <rc> <xy> <min> <max> (genatom)) + (make total ^net-name <nn> ^row-col <rc> ^coor <xy> ^level-pins (compute <cou1> + <cou3>) ^total-pins (compute <cou2> + <cou4>) ^min-xy <min> ^max-xy <max1> ^nets (substr <t1> nets inf) (substr <t2> nets inf)) +) + +(p p308 + { <p> (place-holder <rc> <xy> <min> <max> <id>) } + (place-holder <rc> <xy> <min> <max> <> <id>) + --> + (remove <p>) +) + +(p p309 + (<< lmerge rmerge >>) + { <p> (place-holder <rc> <xy> <min> <max> <id>) } + - (total ^row-col <rc> ^coor <xy> ^max-xy < <min>) + --> + (remove <p>) +) + +(p p310 + (<< lmerge rmerge >>) + { <p> (place-holder <rc> <xy> <min> <max> <id>) } + - (total ^row-col <rc> ^coor <xy> ^min-xy > <max>) + --> + (remove <p>) +) + +(p p311 + (context ^present merge) + { <l> (lmerge <nn> <rc> <xy> <min> <max>) } + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max>) } + --> + (remove <l> <t>) +) + +(p p312 + (context ^present merge) + { <l> (rmerge <nn> <rc> <xy> <min> <max>) } + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max>) } + --> + (remove <l> <t>) +) + +(p p313 + (context ^present merge) + (total ^level-pins <cou> ^total-pins <cou>) + - (total ^level-pins { <cou1> > <cou> } ^total-pins <cou1>) + { <m> (maximum-total < <cou>) } + --> + (modify <m> ^2 <cou>) +) + +(p p314 + (context ^present merge) + (total ^row-col row ^coor 1 ^level-pins <cou> ^total-pins <cou>) + - (total ^row-col row ^coor 1 ^level-pins { <cou1> > <cou> } ^total-pins <cou1>) + { <m> (maximum-total ^5 1 < <cou>) } + --> + (modify <m> ^6 <cou>) +) + +(p p315 + (context ^present merge) + (last-row <lr>) + (total ^row-col row ^coor <lr> ^level-pins <cou> ^total-pins <cou>) + - (total ^row-col row ^coor <lr> ^level-pins { <cou1> > <cou> } ^total-pins <cou1>) + { <m> (maximum-total ^7 <lr> < <cou>) } + --> + (modify <m> ^8 <cou>) +) + +(p p316 + (context ^present merge) + (total ^level-pins <cou1> ^total-pins <cou2>) + - (total ^level-pins > <cou1> ^total-pins > <cou2>) + { <m> (maximum-total <garb4> { <min1> < <cou1> }) } + --> + (modify <m> ^3 <cou1> ^4 <cou2>) +) + +(p p317 + { <con> (context ^present merge) } + --> + (modify <con> ^present delete-totals) + (make goal cleanup eliminate-total) + (make goal cleanup merge-direction) +) + +(p p318 + (context ^present delete-totals) + (maximum-total <max> <garb1> <garb2>) + { <t> (total ^level-pins { <cou> < <max> } ^total-pins <> <cou>) } + --> + (remove <t>) +) + +(p p319 + (context ^present delete-totals) + (maximum-total ^5 1 ^6 <cou>) + { <t> (total ^row-col row ^coor 1 ^level-pins { <cou1> < <cou> } ^total-pins <cou1>) } + --> + (remove <t>) +) + +(p p320 + (context ^present delete-totals) + (maximum-total ^7 <lr> ^8 <cou>) + { <t> (total ^row-col row ^coor <lr> ^level-pins { <cou1> < <cou> } ^total-pins <cou1>) } + --> + (remove <t>) +) + +(p p321 + (context ^present delete-totals) + (maximum-total <garb1> <min> <max>) + { <t> (total ^level-pins { <cou> < <min> }) } + (last-row <lr>) + (total ^row-col row ^coor { <> 1 <> <lr> }) + --> + (remove <t>) +) + +(p p322 + (context ^present delete-totals) + (total ^row-col <rc> ^coor <xy> ^level-pins <min> ^total-pins <max>) + { <t1> (total ^row-col <rc> ^coor <xy> ^level-pins { <cou> <= <min> } ^total-pins > <max>) } + --> + (remove <t1>) +) + +(p p323 + (context ^present delete-totals) + { <m> (maximum-total <garb1> <garb2> <garb3>) } + --> + (remove <m>) +) + +(p p324 + { <c1> (context ^present delete-totals) } + - (maximum-total) + { <t1> (total ^net-name <nn1> ^row-col row ^coor 1) } + { <t2> (total ^net-name <nn2> ^row-col row ^coor <lr>) } + - (total ^row-col row ^coor { <> 1 <> <lr> }) + (last-row <lr>) + --> + (remove <c1> <t1> <t2>) + (make change-priority) + (make tran-total row 1 (substr <t1> nets inf) end) + (make tran-total row <lr> (substr <t2> nets inf) end) + (make goal cleanup total) +) + +(p p325 + (context ^present delete-totals) + - (maximum-total) + (total ^net-name <nn1> ^row-col row ^coor 1) + (total ^net-name <nn2> ^row-col row ^coor <lr>) + { <t1> (total ^net-name <> <nn1> ^row-col row ^coor 1) } + (last-row <lr>) + --> + (remove <t1>) +) + +(p p326 + { <t1> (tran-total <rc> <xy1> end) } + { <t2> (tran-total <rc> <> <xy1> end) } + --> + (remove <t2>) + (modify <t1> ^4 nil) +) + +(p p519 + (context ^present random1) + (net ^net-name <nn> ^net-no-of-pins 2) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn>) + (vertical-layer <lay>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> <= <gy1> } ^grid-layer <lay>) + (vertical ^net-name nil ^min { <vmin1> <= <gy1> } ^max { <vmax1> > <vmin1> >= <gy1> } ^com <gx1> ^layer <lay> ^compo <gx2> ^commo <cmo> ^min-net <vnn1>) + (vertical ^net-name nil ^min { <vmin2> <= <gy2> } ^max { <vmax2> > <vmin2> >= <gy2> >= <vmin1> } ^com <gx2> ^layer <lay> ^compo <cpo> ^commo <garb1> ^max-net <vnn2>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> >= <gx2> > <hmin> } ^com { <hcom> <= <vmax1> >= <vmin1> <= <vmax2> >= <vmin2> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + - (horizontal ^net-name <> nil ^com <hcom>) + --> + (remove 1 3 5) + (make vertical ^com <gx1> ^layer <lay> ^min <vmin1> ^max <hcom> ^compo <gx2> ^commo <cmo> ^min-net <vnn1> ^max-net <nn>) + (modify 6 ^min <gy1> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <lay> ^min <hcom> ^max <vmax2> ^compo <cpo> ^commo <gx1> ^min-net <nn> ^max-net <vnn2>) + (modify 7 ^max <gy2> ^max-net <nn>) + (make horizontal ^min <hmin> ^max <gx1> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 8 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <lay> ^min <hcom> ^max <gy1> ^commo <cmo> ^compo <gx2> ^net-name <nn> ^pin-name <pn>) + (make vertical ^com <gx2> ^layer <lay> ^max <hcom> ^min <gy2> ^commo <gx1> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <hcom> ^layer <lay> ^min <gx1> ^max <gx2> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p520 + (context ^present random1) + (net ^net-name <nn> ^net-no-of-pins 2) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn>) + (horizontal-layer <lay>) + (ff ^net-name <nn> ^grid-x { <gx2> >= <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <lay>) + (horizontal ^net-name nil ^min { <hmin1> <= <gx1> } ^max { <hmax1> > <hmin1> >= <gx1> } ^com <gy1> ^layer <lay> ^compo <gy2> ^commo <cmo> ^max-net <hnn1>) + (horizontal ^net-name nil ^min { <hmin2> <= <gx2> } ^max { <hmax2> > <hmin2> >= <gx2> >= <hmax1> } ^com <gy2> ^layer <lay> ^compo <cpo> ^commo <garb1> ^min-net <hnn2>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> >= <gy2> > <vmin> } ^com { <vcom> <= <hmax1> >= <hmin1> <= <hmax2> >= <hmin2> } ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + - (vertical ^net-name <> nil ^com <vcom>) + --> + (remove 1 3 5) + (make horizontal ^com <gy1> ^layer <lay> ^min <vcom> ^max <hmax1> ^compo <gy2> ^commo <cmo> ^min-net <nn> ^max-net <hnn1>) + (modify 6 ^max <gx1> ^max-net <nn>) + (make horizontal ^com <gy2> ^layer <lay> ^min <hmin2> ^max <vcom> ^compo <cpo> ^commo <gy1> ^min-net <hnn2> ^max-net <nn>) + (modify 7 ^min <gx2> ^min-net <nn>) + (make vertical ^min <vmin> ^max <gy1> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 8 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <lay> ^min <gx1> ^max <vcom> ^commo <cmo> ^compo <gy2> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <lay> ^min <vcom> ^max <gx2> ^commo <gy1> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (make vertical ^com <vcom> ^layer <lay> ^min <gy1> ^max <gy2> ^commo <vcmo> ^compo <vcpo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p521 + (context ^present random1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^com { <vcom1> > <gx> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { >= <gx> < <vcom1> }) + (vertical ^com { <vcom2> <= <vcom1> > <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <vcom2>) + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom2> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom2> ^max >= <vcom2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <= <vcom2> >= <gx> } ^layer <lay>) + - (ff ^net-name <nn> ^grid-x < <gx>) + - (ff ^grid-x <vcom2> ^grid-y <gy>) + --> + (make made-random-move) + (make horizontal ^min <hmin> ^layer <lay> ^max <gx> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <vcom2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <gx> ^max <vcom2> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify 2 ^grid-x <vcom2> ^grid-layer <lay> ^can-chng-layer nil ^came-from west) +) + +(p p522 + (context ^present random1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^com { <vcom1> < <gx> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { <= <gx> > <vcom1> }) + (vertical ^com { <vcom2> >= <vcom1> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcom2> ^max >= <gx>) + (horizontal ^net-name nil ^min { <hmin> <= <vcom2> } ^max { > <hmin> >= <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom2> ^max >= <vcom2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <= <gx> >= <vcom2> } ^layer <lay>) + - (ff ^net-name <nn> ^grid-x > <gx>) + - (ff ^grid-x <vcom2> ^grid-y <gy>) + --> + (make made-random-move) + (make horizontal ^min <hmin> ^layer <lay> ^max <vcom2> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <vcom2> ^max <gx> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify 2 ^grid-x <vcom2> ^grid-layer <lay> ^can-chng-layer nil ^came-from east) +) + +(p p523 + (context ^present random1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <vcom1> < <gx> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { <= <gx> > <vcom1> }) + (vertical ^com { <vcom2> >= <vcom1> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcom2> ^max >= <gx>) + (horizontal ^net-name nil ^min { <hmin> <= <vcom2> } ^max { > <hmin> >= <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom2> ^max >= <vcom2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <= <gx> >= <vcom2> } ^layer <lay>) + - (ff ^net-name <nn> ^grid-x > <gx>) + - (ff ^grid-x <vcom2> ^grid-y <gy>) + --> + (make made-random-move) + (make horizontal ^min <hmin> ^layer <lay> ^max <vcom2> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <vcom2> ^max <gx> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify 2 ^grid-x <vcom2> ^grid-layer <lay> ^can-chng-layer nil ^came-from east) +) + +(p p524 + (context ^present random1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^com { <hcom1> < <gy> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom1> <= <gy> }) + (horizontal ^com { <hcom2> >= <hcom1> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <hcom2> ^max >= <gy>) + (vertical ^net-name nil ^min { <vmin> <= <hcom2> } ^max { > <vmin> >= <gy> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <hcom2> <= <gy> } ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom2> ^max >= <hcom2> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y > <gy>) + - (ff ^grid-x <gx> ^grid-y <hcom2>) + --> + (make made-random-move) + (make vertical ^min <vmin> ^layer <lay> ^max <hcom2> ^com <gx> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <hcom2> ^max <gy> ^commo <vcmo> ^compo <vcpo> ^layer <lay> ^com <gx>) + (modify 2 ^grid-y <hcom2> ^grid-layer <lay> ^can-chng-layer nil ^came-from north) +) + +(p p525 + (context ^present random1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^com { <hcom1> > <gy> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <hcom1> >= <gy> }) + (horizontal ^com { <hcom2> <= <hcom1> > <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <hcom2>) + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom2> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <gy> <= <hcom2> } ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom2> ^max >= <hcom2> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y < <gy>) + - (ff ^grid-x <gx> ^grid-y <hcom2>) + --> + (make made-random-move) + (make vertical ^min <vmin> ^layer <lay> ^max <gy> ^com <gx> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <hcom2> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <gy> ^max <hcom2> ^commo <vcmo> ^compo <vcpo> ^layer <lay> ^com <gx>) + (modify 2 ^grid-y <hcom2> ^grid-layer <lay> ^can-chng-layer nil ^came-from south) +) + +(p p526 + (context ^present random1) + --> + (remove 1) + (make context ^present check-random-move) +) + +(p p527 + { <c> (context ^present check-random-move) } + { <m> (made-random-move) } + --> + (remove <c> <m>) + (make context ^present check-for-routed-net) + (make goal cleanup made-random-move) +) + +(p p528 + { <c> (context ^present check-random-move) } + - (made-random-move) + --> + (remove <c>) + (make context ^present random2) +) + +(p p529 + (context ^present random2) + --> + (write (crlf) |Sorry, I can not proceed anymore because of my ignorance.|) + (halt) +) + +(p p530 + (context ^present random0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + - (ff ^net-name <nn> ^pin-name <> <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^com { <hcom1> < <gy> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom1> <= <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <hcom1> ^max >= <gy>) + (vertical ^net-name nil ^min { <vmin> <= <hcom1> } ^max { > <vmin> >= <gy> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + (vertical-layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <hcom1> <= <gy> } ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom1> ^max >= <hcom1> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y > <gy>) + --> + (remove 1) + (make vertical ^min <vmin> ^layer <lay> ^max <hcom1> ^com <gx> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn>) + (modify 4 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <hcom1> ^max <gy> ^commo <vcmo> ^compo <vcpo> ^layer <lay> ^com <gx>) + (modify 2 ^grid-y <hcom1> ^grid-layer <lay> ^can-chng-layer nil ^came-from north) + (make context ^present propagate-constraint) +) + +(p p531 + (context ^present random0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + - (ff ^net-name <nn> ^pin-name <> <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^com { <hcom1> > <gy> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <hcom1> >= <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <hcom1>) + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom1> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + (vertical-layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <gy> <= <hcom1> } ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom1> ^max >= <hcom1> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y < <gy>) + --> + (remove 1) + (make vertical ^min <vmin> ^layer <lay> ^max <gy> ^com <gx> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn>) + (modify 4 ^min <hcom1> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <gy> ^max <hcom1> ^commo <vcmo> ^compo <vcpo> ^layer <lay> ^com <gx>) + (modify 2 ^grid-y <hcom1> ^grid-layer <lay> ^can-chng-layer nil ^came-from south) + (make context ^present propagate-constraint) +) + +(p p532 + (context ^present random0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + - (ff ^net-name <nn> ^pin-name <> <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^com { <vcom1> < <gx> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { <= <gx> > <vcom1> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcom1> ^max >= <gx>) + (horizontal ^net-name nil ^min { <hmin> <= <vcom1> } ^max { > <hmin> >= <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + (horizontal-layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom1> ^max >= <vcom1> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { >= <vcom1> <= <gx> } ^layer <lay>) + - (ff ^net-name <nn> ^grid-x > <gx>) + --> + (remove 1) + (make horizontal ^min <hmin> ^layer <lay> ^max <vcom1> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify 4 ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <vcom1> ^max <gx> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify 2 ^grid-x <vcom1> ^grid-layer <lay> ^can-chng-layer nil ^came-from east) + (make context ^present propagate-constraint) +) + +(p p533 + (context ^present random0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + - (ff ^net-name <nn> ^pin-name <> <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^com { <vcom1> > <gx> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { >= <gx> < <vcom1> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <vcom1>) + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom1> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + (horizontal-layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom1> ^max >= <vcom1> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { >= <gx> <= <vcom1> } ^layer <lay>) + - (ff ^net-name <nn> ^grid-x < <gx>) + --> + (remove 1) + (make horizontal ^min <hmin> ^layer <lay> ^max <gx> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify 4 ^min <vcom1> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <gx> ^max <vcom1> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify 2 ^grid-x <vcom1> ^grid-layer <lay> ^can-chng-layer nil ^came-from west) + (make context ^present propagate-constraint) +) + +(p p534 + { <c> (context ^present random2) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (vertical ^status nil ^net-name { <nn> <> nil } ^com > <gx>) + { <h> (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> > <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + --> + (make horizontal ^min <hmin> ^layer <lay> ^max <gx> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify <h> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <gx> ^max <gx2> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify <ff> ^grid-x <gx2> ^grid-layer <lay> ^can-chng-layer nil ^came-from west) + (remove <c>) + (make context ^present check-for-routed-net) +) + +(p p535 + { <c> (context ^present random2) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (vertical ^status nil ^net-name { <nn> <> nil } ^com < <gx>) + { <h> (horizontal ^net-name nil ^min { <hmin> < <gx> } ^max { <hmax> >= <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) } + (congestion ^direction col ^coordinate <gx> ^como <gx2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + --> + (make horizontal ^min <hmin> ^layer <lay> ^max <gx2> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify <h> ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <gx2> ^max <gx> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify <ff> ^grid-x <gx2> ^grid-layer <lay> ^can-chng-layer nil ^came-from east) + (remove <c>) + (make context ^present check-for-routed-net) +) + +(p p536 + { <c> (context ^present random2) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^com > <gy>) + { <h> (vertical ^net-name nil ^min { <hmin> <= <gy> } ^max { <hmax> > <gy> } ^com <gx> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + --> + (make vertical ^min <hmin> ^layer <lay> ^max <gy> ^com <gx> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify <h> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <gy> ^max <gy2> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gx>) + (modify <ff> ^grid-y <gy2> ^grid-layer <lay> ^can-chng-layer nil ^came-from south) + (remove <c>) + (make context ^present check-for-routed-net) +) + +(p p537 + { <c> (context ^present random2) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^com < <gy>) + { <h> (vertical ^net-name nil ^min { <hmin> < <gy> } ^max { <hmax> >= <gy> } ^com <gx> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) } + (congestion ^direction row ^coordinate <gy> ^como <gy2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + --> + (make vertical ^min <hmin> ^layer <lay> ^max <gy2> ^com <gx> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify <h> ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <gy2> ^max <gy> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gx>) + (modify <ff> ^grid-y <gy2> ^grid-layer <lay> ^can-chng-layer nil ^came-from north) + (remove <c>) + (make context ^present check-for-routed-net) +) + +(p p558 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> <= <nmax> } ^grid-y <gy>) + - (ff ^net-name <nn> ^grid-x { > <gx1> < <gx2> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (horizontal ^net-name nil ^min <= <gx1> ^max >= <gx2> ^com <gy> ^layer <> <lay>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx1> ^max >= <gx2> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2 3) + (make horizontal ^com <gy> ^min <min> ^max <gx1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx1> ^max <gx2> ^net-name <nn> ^pin-name <pn>) +) + +(p p559 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx2> > <gx1> <= <nmax> }) + - (ff ^net-name <nn> ^grid-x { > <gx1> < <gx2> } ^grid-y <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx1> < <gx2> }) + (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx1> ^max >= <gx2> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2) + (make horizontal ^com <gy> ^min <min> ^max <gx1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx1> ^max <gx2> ^net-name <nn> ^pin-name <pn>) +) + +(p p560 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx2> < <gx1> >= <nmin> }) + - (ff ^net-name <nn> ^grid-x { < <gx1> > <gx2> } ^grid-y <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { < <gx1> > <gx2> }) + (horizontal ^net-name nil ^min { <min> <= <gx2> } ^max { <max> >= <gx1> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx2> ^max >= <gx1> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2) + (make horizontal ^com <gy> ^min <min> ^max <gx2> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx1> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx2> ^max <gx1> ^net-name <nn> ^pin-name <pn>) +) + +(p p561 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx2> > <gx1> <= <nmax> }) + - (ff ^net-name <nn> ^grid-x { > <gx1> < <gx2> } ^grid-y <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx1> < <gx2> }) + (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (horizontal-layer <lay>) + (dominant-layer) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx1> ^max >= <gx2> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2) + (make horizontal ^com <gy> ^min <min> ^max <gx1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx1> ^max <gx2> ^net-name <nn> ^pin-name <pn>) +) + +(p p562 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx2> < <gx1> >= <nmin> }) + - (ff ^net-name <nn> ^grid-x { < <gx1> > <gx2> } ^grid-y <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { < <gx1> > <gx2> }) + (horizontal ^net-name nil ^min { <min> <= <gx2> } ^max { <max> >= <gx1> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (horizontal-layer <lay>) + (dominant-layer) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx2> ^max >= <gx1> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2) + (make horizontal ^com <gy> ^min <min> ^max <gx2> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx1> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx2> ^max <gx1> ^net-name <nn> ^pin-name <pn>) +) + +(p p563 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> <= <nmax> } ^grid-y <gy>) + - (ff ^net-name <nn> ^grid-x { > <gx1> < <gx2> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (horizontal-layer <lay>) + (dominant-layer) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx1> ^max >= <gx2> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2 3) + (make horizontal ^com <gy> ^min <min> ^max <gx1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx1> ^max <gx2> ^net-name <nn> ^pin-name <pn>) +) + +(p p564 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy1> <= <nmax> } ^grid-x <gx>) + - (ff ^net-name <nn> ^grid-y { > <gy1> < <gy2> } ^grid-x <gx>) + (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (vertical ^net-name nil ^min <= <gy1> ^max >= <gy2> ^com <gx> ^layer <> <lay>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy1> ^max >= <gy2> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2 3) + (make vertical ^com <gx> ^min <min> ^max <gy1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy1> ^max <gy2> ^net-name <nn> ^pin-name <pn>) +) + +(p p565 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy2> > <gy1> <= <nmax> }) + - (ff ^net-name <nn> ^grid-y { > <gy1> < <gy2> } ^grid-x <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy1> < <gy2> }) + (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy1> ^max >= <gy2> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2) + (make vertical ^com <gx> ^min <min> ^max <gy1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy1> ^max <gy2> ^net-name <nn> ^pin-name <pn>) +) + +(p p566 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy2> < <gy1> >= <nmin> }) + - (ff ^net-name <nn> ^grid-y { > <gy2> < <gy1> } ^grid-x <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy2> < <gy1> }) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { <max> >= <gy1> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy2> ^max >= <gy1> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2) + (make vertical ^com <gx> ^min <min> ^max <gy2> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy1> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy2> ^max <gy1> ^net-name <nn> ^pin-name <pn>) +) + +(p p567 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy2> > <gy1> <= <nmax> }) + - (ff ^net-name <nn> ^grid-y { > <gy1> < <gy2> } ^grid-x <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy1> < <gy2> }) + (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (vertical-layer <lay>) + (dominant-layer) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy1> ^max >= <gy2> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2) + (make vertical ^com <gx> ^min <min> ^max <gy1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy1> ^max <gy2> ^net-name <nn> ^pin-name <pn>) +) + +(p p568 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy2> < <gy1> >= <nmin> }) + - (ff ^net-name <nn> ^grid-y { > <gy2> < <gy1> } ^grid-x <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy2> < <gy1> }) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { <max> >= <gy1> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (vertical-layer <lay>) + (dominant-layer) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy2> ^max >= <gy1> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2) + (make vertical ^com <gx> ^min <min> ^max <gy2> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy1> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy2> ^max <gy1> ^net-name <nn> ^pin-name <pn>) +) + +(p p569 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy1> <= <nmax> } ^grid-x <gx>) + - (ff ^net-name <nn> ^grid-y { > <gy1> < <gy2> } ^grid-x <gx>) + (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (vertical-layer <lay>) + (dominant-layer) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy1> ^max >= <gy2> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2 3) + (make vertical ^com <gx> ^min <min> ^max <gy1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy1> ^max <gy2> ^net-name <nn> ^pin-name <pn>) +) + +(p p570 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <max> >= <nmin> <= <nmax> } ^com <gy> ^layer <garb2> ^compo <garb3> ^commo <garb4> ^pin-name <pn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <max> ^max > <max> ^com <gy>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <min> > <max> <= <nmax> } ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <min> ^max >= <min> ^com <gy>) + (horizontal ^net-name nil ^min <max> ^max { <min> > <max> } ^com <gy> ^layer <garb5> ^compo <garb6> ^commo <garb7>) + --> + (modify 4 ^net-name <nn> ^pin-name <pn> ^max-net nil ^min-net nil) +) + +(p p571 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <max> >= <nmin> <= <nmax> } ^com <gx> ^layer <garb2> ^compo <garb3> ^commo <garb4> ^pin-name <pn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <max> ^max > <max> ^com <gx>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min { <min> > <max> <= <nmax> } ^com <gx>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <min> ^max >= <min> ^com <gx>) + (vertical ^net-name nil ^min <max> ^max { <min> > <max> } ^com <gx> ^layer <garb5> ^compo <garb6> ^commo <garb7>) + --> + (modify 4 ^net-name <nn> ^pin-name <pn> ^max-net nil ^min-net nil) +) + +(p p572 + { <next> (next-segment <nn> row <gy>) } + (ff ^net-name <nn> ^grid-y <gy> ^pin-name <pn> ^came-from north) + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <np> ^no-of-bottom-pins <garb1>) + - (ff ^net-name <nn> ^grid-y < <gy>) + { <ff> (ff ^net-name <nn> ^grid-y { <gy2> > <gy> } ^pin-name <pn2> ^grid-x <gx> ^grid-layer <lay> ^came-from north) } + { <v1> (vertical ^net-name nil ^min { <min> <= <gy> } ^max { > <min> >= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <mn>) } + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^com { < <gy2> >= <gy> } ^layer <lay>) + --> + (make vertical ^net-name nil ^max <gy> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify <v1> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn2>) + (modify <ff> ^grid-y <gy> ^can-chng-layer nil) + (modify <next> ^5 useless) +) + +(p p573 + { <next> (next-segment <nn> row <gy>) } + (ff ^came-from south ^net-name <nn> ^grid-y <gy> ^pin-name <pn>) + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <garb1> ^no-of-bottom-pins <np>) + - (ff ^net-name <nn> ^grid-y > <gy>) + { <ff> (ff ^net-name <nn> ^grid-y { <gy2> < <gy> } ^pin-name <pn2> ^grid-x <gx> ^grid-layer <lay> ^came-from south) } + { <v1> (vertical ^net-name nil ^max { <max> >= <gy> } ^min { < <max> <= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^com { > <gy2> <= <gy> } ^layer <lay>) + --> + (make vertical ^net-name nil ^max <max> ^min <gy> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <nn> ^max-net <mn>) + (modify <v1> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <gy2> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn2>) + (modify <ff> ^grid-y <gy> ^can-chng-layer nil) + (modify <v1> ^5 useless) +) + +(p p574 + (next-segment <nn> row <gy> <gg1> <nmin> <nmax>) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy> } ^grid-x { <gx> >= <nmin> <= <nmax> } ^grid-layer <lay> ^pin-name <pn>) + (vertical ^net-name nil ^min { <min> <= <gy> } ^max { > <min> >= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <mn>) + (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy2> ^com <gx>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^com <gx>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <gy> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify 3 ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <gy> ^can-chng-layer nil) + (modify 1 ^2 <nn>) +) + +(p p575 + (next-segment <nn> row <gy> <gg1> <nmin> <nmax>) + (vertical ^net-name { <nn> <> nil } ^min { <gy2> > <gy> } ^com { <gx> >= <nmin> <= <nmax> } ^layer <lay> ^pin-name <pn>) + (vertical ^net-name nil ^min { < <gy2> <= <gy> } ^max <gy2> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy2> ^com <gx>) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy2>) + - (vertical ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy2> ^com <gx>) + - (ff ^net-name <> <nn> ^grid-x <gx>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + --> + (modify 3 ^max <gy> ^max-net <nn>) + (modify 2 ^min <gy>) + (make ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) + (modify 1 ^2 <nn>) +) + +(p p576 + (next-segment <nn> row <gy> <gg1> <nmin> <nmax>) + (ff ^net-name <nn> ^grid-y { <gy2> < <gy> } ^grid-x { <gx> >= <nmin> <= <nmax> } ^grid-layer <lay> ^pin-name <pn>) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { > <min> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <mn>) + (vertical-s ^net-name <nn> ^min <= <gy2> ^max >= <gy> ^com <gx>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^com <gx>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <gy2> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify 3 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <gy2> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <gy> ^can-chng-layer nil) + (modify 1 ^2 <nn>) +) + +(p p577 + (next-segment <nn> row <gy> <gg1> <nmin> <nmax>) + (vertical ^net-name { <nn> <> nil } ^min { <gy2> < <gy> } ^com { <gx> >= <nmin> <= <nmax> } ^layer <lay> ^pin-name <pn>) + (vertical ^net-name nil ^min <gy2> ^max { > <gy2> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + (vertical-s ^net-name <nn> ^min <= <gy2> ^max >= <gy> ^com <gx>) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy2>) + - (vertical ^net-name { <nn> <> nil } ^min <= <gy2> ^max >= <gy> ^com <gx>) + - (ff ^net-name <> <nn> ^grid-x <gx>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + --> + (modify 3 ^min <gy> ^min-net <nn>) + (modify 2 ^max <gy>) + (make ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from south) + (modify 1 ^2 <nn>) +) + +(p p578 + (next-segment <nn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <garb2>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <garb3> ^compo <garb4> ^commo <garb5>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <garb6> ^compo <garb7> ^commo <garb8>) + --> + (remove 2) +) + +(p p579 + (next-segment <nn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <garb2>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <gx> ^max <gx> ^com <gy>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <gx> ^max > <gx> ^com <gy>) + --> + (remove 2) +) + +(p p580 + (change-priority) + { <n> (next-segment ^5 useless) } + --> + (modify <n> ^5 nil) +) + +(p p581 + (change-priority) + { <n> (next-segment <nn> col <x> useless <min> <max>) } + (vertical-s ^net-name <nn> ^com <x> ^sum 2 ^difference 0) + (last-row <lr>) + --> + (modify <n> ^5 nil 1 <lr>) +) + +(p p582 + (change-priority) + { <n> (next-segment <nn> row <y> useless <min> <max>) } + (horizontal-s ^net-name <nn> ^com <x> ^sum 2 ^difference 0) + (last-col <lc>) + --> + (modify <n> ^5 nil 1 <lc>) +) + +(p p583 + { <n> (next-segment <nn> <rc> <xy> nil) } + - (next-segment ^5 <> nil) + --> + (remove <n>) + (make move-ff <nn> <rc> <xy>) +) + +(p p584 + { <c> (change-priority) } + --> + (remove <c>) + (make end-of-specialized-move-ff) +) + +(p p585 + (move-ff <nn> row <xy>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <xy> ^layer <lay> ^compo <cpo> ^commo <garb1>) + { <ff> (ff ^came-from south ^net-name { <nn1> <> <nn> } ^grid-x { <gx> >= <min> <= <max> } ^grid-y <xy> ^grid-layer { <flay> <> <lay> }) } + { <v1> (vertical ^status nil ^net-name <nn1> ^min < <xy> ^max <xy> ^com <gx> ^layer <flay>) } + - (horizontal ^net-name nil ^min <= <gx> ^max >= <gx> ^com <xy> ^layer <flay>) + { <v2> (vertical ^net-name nil ^min <xy> ^max { <garb4> > <xy> } ^com <gx> ^layer <flay> ^compo <garb2> ^commo <garb3>) } + --> + (modify <v2> ^min <cpo> ^min-net <nn1>) + (modify <v1> ^max <cpo>) + (modify <ff> ^grid-y <cpo> ^can-chng-layer nil) +) + +(p p586 + (move-ff <nn> row <xy>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <xy> ^layer <lay> ^compo <garb1> ^commo <cmo>) + { <ff> (ff ^came-from north ^net-name { <nn1> <> <nn> } ^grid-x { <gx> >= <min> <= <max> } ^grid-y <xy> ^grid-layer { <flay> <> <lay> }) } + { <v1> (vertical ^status nil ^net-name <nn1> ^min <xy> ^max > <xy> ^com <gx> ^layer <flay>) } + - (horizontal ^net-name nil ^min <= <gx> ^max >= <gx> ^com <xy> ^layer <flay>) + { <v2> (vertical ^net-name nil ^min <vmin> ^max { <xy> > <vmin> } ^com <gx> ^layer <flay> ^compo <garb2> ^commo <garb3>) } + --> + (modify <v2> ^max <cmo> ^max-net <nn1>) + (modify <v1> ^min <cmo>) + (modify <ff> ^grid-y <cmo> ^can-chng-layer nil) +) + +(p p587 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <min> ^max <max>) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max>) } + --> + (remove <h>) +) + +(p p588 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <min> ^max <max>) + { <v> (vertical-s ^net-name <nn> ^min <min> ^max <max>) } + --> + (remove <v>) +) + +(p p589 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (ff ^net-name <nn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y { <gy> < <com> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> } ^max { <vmax> >= <com> } ^com <gx> ^id <id>) } + (vertical ^net-name nil ^min <= <gy> ^max >= <com> ^com <gx>) + - (vertical-s ^net-name <> <nn> ^com <gx>) + --> + (remove <v>) + (make next-segment <nn> col <gx> nil <vmin> <vmax>) +) + +(p p590 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (ff ^net-name <nn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y { <gy> > <com> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <com> } ^max { <vmax> >= <gy> } ^com <gx> ^id <id>) } + (vertical ^net-name nil ^min <= <com> ^max >= <gy> ^com <gx>) + - (vertical-s ^net-name <> <nn> ^com <gx>) + --> + (remove <v>) + (make next-segment <nn> col <gx> nil <vmin> <vmax>) +) + +(p p591 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (horizontal ^net-name <nn> ^min { <hmin2> >= <hmin1> } ^max { <hmax2> <= <hmax1> } ^com { <hcom2> < <hcom1> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <hcom2> } ^max { <vmax> >= <hcom1> } ^com { <vcom> >= <hmin2> <= <hmax2> } ^id <id>) } + (vertical ^net-name nil ^min <= <hcom2> ^max >= <hcom1> ^com { <vcom2> >= <hmin2> <= <hmax2> }) + - (vertical-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> col <vcom2> nil <vmin> <vmax>) +) + +(p p592 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (horizontal ^net-name <nn> ^min { <hmin2> >= <hmin1> } ^max { <hmax2> <= <hmax1> } ^com { <hcom2> > <hcom1> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <hcom1> } ^max { <vmax> >= <hcom2> } ^com { <vcom> >= <hmin2> <= <hmax2> } ^id <id>) } + (vertical ^net-name nil ^min <= <hcom1> ^max >= <hcom2> ^com { <vcom2> >= <hmin2> <= <hmax2> }) + - (vertical-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> col <vcom2> nil <vmin> <vmax>) +) + +(p p593 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (horizontal ^net-name <nn> ^min { <hmin2> >= <hmin1> <= <hmax1> } ^max { <hmax2> >= <hmax1> } ^com { <hcom2> < <hcom1> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <hcom2> } ^max { <vmax> >= <hcom1> } ^com { <vcom> >= <hmin2> <= <hmax1> } ^id <id>) } + (vertical ^net-name nil ^min <= <hcom2> ^max >= <hcom1> ^com { <vcom2> >= <hmin2> <= <hmax1> }) + - (vertical-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> col <vcom2> nil <vmin> <vmax>) +) + +(p p594 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (horizontal ^net-name <nn> ^min { <hmin2> >= <hmin1> <= <hmax1> } ^max { <hmax2> >= <hmax1> } ^com { <hcom2> > <hcom1> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <hcom1> } ^max { <vmax> >= <hcom2> } ^com { <vcom> >= <hmin2> <= <hmax1> } ^id <id>) } + (vertical ^net-name nil ^min <= <hcom1> ^max >= <hcom2> ^com { <vcom2> >= <hmin2> <= <hmax1> }) + - (vertical-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> col <vcom2> nil <vmin> <vmax>) +) + +(p p595 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (ff ^net-name <nn> ^grid-x { <gx> < <com> } ^grid-y { <gy> >= <min> <= <max> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <gx> } ^max { <vmax> >= <com> } ^com <gy> ^id <id>) } + (horizontal ^net-name nil ^min <= <gx> ^max >= <com> ^com <gy>) + - (horizontal-s ^net-name <> <nn> ^com <gy>) + --> + (remove <v>) + (make next-segment <nn> row <gy> nil <vmin> <vmax>) +) + +(p p596 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (ff ^net-name <nn> ^grid-x { <gx> > <com> } ^grid-y { <gy> >= <min> <= <max> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <com> } ^max { <vmax> >= <gx> } ^com <gy> ^id <id>) } + (horizontal ^net-name nil ^min <= <com> ^max >= <gx> ^com <gy>) + - (horizontal-s ^net-name <> <nn> ^com <gy>) + --> + (remove <v>) + (make next-segment <nn> row <gy> nil <vmin> <vmax>) +) + +(p p597 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (vertical ^net-name <nn> ^min { <hmin2> >= <hmin1> } ^max { <hmax2> <= <hmax1> } ^com { <hcom2> < <hcom1> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <hcom2> } ^max { <vmax> >= <hcom1> } ^com { <vcom> >= <hmin2> <= <hmax2> } ^id <id>) } + (horizontal ^net-name nil ^min <= <hcom2> ^max >= <hcom1> ^com { <vcom2> >= <hmin2> <= <hmax2> }) + - (horizontal-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> row <vcom2> nil <vmin> <vmax>) +) + +(p p598 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (vertical ^net-name <nn> ^min { <hmin2> >= <hmin1> } ^max { <hmax2> <= <hmax1> } ^com { <hcom2> > <hcom1> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <hcom1> } ^max { <vmax> >= <hcom2> } ^com { <vcom> >= <hmin2> <= <hmax2> } ^id <id>) } + (horizontal ^net-name nil ^min <= <hcom1> ^max >= <hcom2> ^com { <vcom2> >= <hmin2> <= <hmax2> }) + - (horizontal-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> row <vcom2> nil <vmin> <vmax>) +) + +(p p599 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (vertical ^net-name <nn> ^min { <hmin2> >= <hmin1> <= <hmax1> } ^max { <hmax2> >= <hmax1> } ^com { <hcom2> < <hcom1> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <hcom2> } ^max { <vmax> >= <hcom1> } ^com { <vcom> >= <hmin2> <= <hmax1> } ^id <id>) } + (horizontal ^net-name nil ^min <= <hcom2> ^max >= <hcom1> ^com { <vcom2> >= <hmin2> <= <hmax1> }) + - (horizontal-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> row <vcom2> nil <vmin> <vmax>) +) + +(p p600 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (vertical ^net-name <nn> ^min { <hmin2> >= <hmin1> <= <hmax1> } ^max { <hmax2> >= <hmax1> } ^com { <hcom2> > <hcom1> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <hcom1> } ^max { <vmax> >= <hcom2> } ^com { <vcom> >= <hmin2> <= <hmax1> } ^id <id>) } + (horizontal ^net-name nil ^min <= <hcom1> ^max >= <hcom2> ^com { <vcom2> >= <hmin2> <= <hmax1> }) + - (horizontal-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> row <vcom2> nil <vmin> <vmax>) +) + +(p p601 + { <m> (move-ff) } + --> + (remove <m>) +) + +(p p602 + { <e> (end-of-specialized-move-ff) } + - (next-segment) + --> + (remove <e>) + (make context ^present check-for-routed-net) +) + +(p p603 + (context ^present << check-for-routed-net propagate-constraint >>) + (<< dominant-layer change-priority next-segment >>) + --> + (remove 2) +) + +(p p244 + (context ^present lshape1) + (<< total-verti counted-verti total counted >>) + --> + (remove 2) +) + +(p p245 + (context ^present lshape1) + (last-row <gy>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) + - (ff ^net-name <nn> ^grid-y <gy> ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> } ^grid-y <gy2>) + - (vertical ^com { > <gx> < <gx2> }) + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy> ^layer <lay> ^commo <hcmo> ^compo <hcpo> ^min-net <mn>) + - (pin ^pin-x <gx2> ^pin-y <hcpo>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + --> + (make horizontal ^layer <lay> ^min <hmin> ^max <gx> ^min-net <mn> ^max-net <nn> ^com <gy> ^commo <hcmo> ^compo <hcpo>) + (modify 5 ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gx> ^max <gx2> ^com <gy> ^commo <hcmo> ^compo <hcpo>) + (modify 3 ^grid-x <gx2> ^came-from west) +) + +(p p246 + (context ^present lshape1) + (last-row <gy>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) + - (ff ^net-name <nn> ^grid-y <gy> ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx> } ^grid-y <gy2>) + - (vertical ^com { > <gx2> < <gx> }) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (pin ^pin-x <gx2> ^pin-y <hcpo>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + --> + (make horizontal ^layer <lay> ^min <hmin> ^max <gx2> ^min-net <mn> ^max-net <nn> ^com <gy> ^commo <hcmo> ^compo <hcpo>) + (modify 5 ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gx2> ^max <gx> ^com <gy> ^commo <hcmo> ^compo <hcpo>) + (modify 3 ^grid-x <gx2> ^came-from east) +) + +(p p247 + (context ^present lshape1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y 1 ^grid-layer <lay> ^pin-name <pn> ^came-from south) + - (ff ^net-name <nn> ^grid-y 1 ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> } ^grid-y <gy2>) + - (vertical ^com { > <gx> < <gx2> }) + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> > <hmin> >= <gx2> } ^com 1 ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (pin ^pin-x <gx2> ^pin-y 0) + - (vertical ^net-name { <> <nn> <> nil } ^min <= 1 ^max >= 1 ^com <gx2> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com 1 ^layer <lay>) + --> + (make horizontal ^layer <lay> ^min <hmin> ^max <gx> ^min-net <mn> ^max-net <nn> ^com 1 ^commo <hcmo> ^compo <hcpo>) + (modify 4 ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gx> ^max <gx2> ^com 1 ^commo <hcmo> ^compo <hcpo>) + (modify 2 ^grid-x <gx2> ^came-from west) +) + +(p p248 + (context ^present lshape1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y 1 ^grid-layer <lay> ^pin-name <pn> ^came-from south) + - (ff ^net-name <nn> ^grid-y 1 ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx> } ^grid-y <gy2>) + - (vertical ^com { > <gx2> < <gx> }) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx> } ^com 1 ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (pin ^pin-x <gx2> ^pin-y 0) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= 1 ^max >= 1 ^com <gx2> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com 1 ^layer <lay>) + --> + (make horizontal ^layer <lay> ^min <hmin> ^max <gx2> ^min-net <mn> ^max-net <nn> ^com 1 ^commo <hcmo> ^compo <hcpo>) + (modify 4 ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gx2> ^max <gx> ^com 1 ^commo <hcmo> ^compo <hcpo>) + (modify 2 ^grid-x <gx2> ^came-from east) +) + +(p p249 + (context ^present lshape1) + (last-col <gx>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from east) + - (ff ^net-name <nn> ^grid-x <gx> ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x <gx2> ^grid-y { <gy2> > <gy> }) + - (horizontal ^com { > <gy> < <gy2> }) + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { <vmax> >= <gy2> > <vmin> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (pin ^pin-x <vcpo> ^pin-y <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (make vertical ^layer <lay> ^min <vmin> ^max <gy> ^min-net <mn> ^max-net <nn> ^com <gx> ^commo <vcmo> ^compo <vcpo>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gy> ^max <gy2> ^com <gx> ^commo <vcmo> ^compo <vcpo>) + (modify 3 ^grid-y <gy2> ^came-from south) +) + +(p p250 + (context ^present lshape1) + (last-col <gx>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from east) + - (ff ^net-name <nn> ^grid-x <gx> ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x <gx2> ^grid-y { <gy2> < <gy> }) + - (horizontal ^com { > <gy2> < <gy> }) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> >= <gy> > <vmin> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (pin ^pin-x <vcpo> ^pin-y <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (make vertical ^layer <lay> ^min <vmin> ^max <gy2> ^min-net <mn> ^max-net <nn> ^com <gx> ^commo <vcmo> ^compo <vcpo>) + (modify 5 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gy2> ^max <gy> ^com <gx> ^commo <vcmo> ^compo <vcpo>) + (modify 3 ^grid-y <gy2> ^came-from north) +) + +(p p251 + (context ^present lshape1) + (ff ^net-name <nn> ^grid-x 1 ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from west) + - (ff ^net-name <nn> ^grid-x 1 ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x <gx2> ^grid-y { <gy2> > <gy> }) + - (horizontal ^com { > <gy> < <gy2> }) + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { <vmax> > <vmin> >= <gy2> } ^com 1 ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (pin ^pin-x 0 ^pin-y <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= 1 ^max >= 1 ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com 1 ^layer <lay>) + --> + (make vertical ^layer <lay> ^min <vmin> ^max <gy> ^min-net <mn> ^max-net <nn> ^com 1 ^commo <vcmo> ^compo <vcpo>) + (modify 4 ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gy> ^max <gy2> ^com 1 ^commo <vcmo> ^compo <vcpo>) + (modify 2 ^grid-y <gy2> ^came-from south) +) + +(p p252 + (context ^present lshape1) + (ff ^net-name <nn> ^grid-x 1 ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from west) + - (ff ^net-name <nn> ^grid-x 1 ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x <gx2> ^grid-y { <gy2> < <gy> }) + - (horizontal ^com { > <gy2> < <gy> }) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy> } ^com 1 ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (pin ^pin-x 0 ^pin-y <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= 1 ^max >= 1 ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com 1 ^layer <lay>) + --> + (make vertical ^layer <lay> ^min <vmin> ^max <gy2> ^min-net <mn> ^max-net <nn> ^com 1 ^commo <vcmo> ^compo <vcpo>) + (modify 4 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gy2> ^max <gy> ^com 1 ^commo <vcmo> ^compo <vcpo>) + (modify 2 ^grid-y <gy2> ^came-from north) +) + +(p p253 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> >= <gy1> > <vmin> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> >= <gx2> > <hmin> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p254 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p255 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p256 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy1>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p257 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + (ff ^net-name { <nn1> <> <nn> } ^grid-y <gy2> ^grid-x < <gx1>) + - (pin ^net-name <nn1> ^pin-x >= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p258 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + (ff ^net-name { <nn1> <> <nn> } ^grid-y <gy2> ^grid-x > <gx1>) + - (pin ^net-name <nn1> ^pin-x <= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p259 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + (ff ^net-name { <nn1> <> <nn> } ^grid-y <gy2> ^grid-x < <gx1>) + - (pin ^net-name <nn1> ^pin-x >= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p260 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx2>) + (ff ^net-name { <nn1> <> <nn> } ^grid-y <gy1> ^grid-x > <gx2>) + - (pin ^net-name <nn1> ^pin-x <= <gx2>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p261 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y < <gy2>) + - (pin ^net-name <nn1> ^pin-y >= <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p262 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y < <gy2>) + - (pin ^net-name <nn1> ^pin-y >= <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p263 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y > <gy2>) + - (pin ^net-name <nn1> ^pin-y <= <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p264 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy1>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx2> ^grid-y > <gy1>) + - (pin ^net-name <nn1> ^pin-y <= <gy1>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p265 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y < <gy2>) + - (pin ^net-name <nn1> ^pin-y >= <gy2>) + (ff ^net-name { <nn2> <> <nn> } ^grid-y <gy2> ^grid-x < <gx1>) + - (pin ^net-name <nn2> ^pin-x >= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p266 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y < <gy2>) + - (pin ^net-name <nn1> ^pin-y >= <gy2>) + (ff ^net-name { <nn2> <> <nn> } ^grid-y <gy2> ^grid-x > <gx1>) + - (pin ^net-name <nn2> ^pin-x <= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p267 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y > <gy2>) + - (pin ^net-name <nn1> ^pin-y <= <gy2>) + (ff ^net-name { <nn2> <> <nn> } ^grid-y <gy2> ^grid-x < <gx1>) + - (pin ^net-name <nn2> ^pin-x >= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p268 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx2> ^grid-y > <gy1>) + - (pin ^net-name <nn1> ^pin-y <= <gy1>) + (ff ^net-name { <nn2> <> <nn> } ^grid-y <gy1> ^grid-x > <gx2>) + - (pin ^net-name <nn2> ^pin-x <= <gx2>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p269 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p270 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p271 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p272 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx2>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p273 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p274 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p275 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p276 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy1>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p277 + (context ^present lshape3) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p278 + (context ^present lshape3) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p279 + (context ^present lshape3) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p280 + (context ^present lshape3) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p281 + (context ^present lshape4) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <garb2>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p282 + (context ^present lshape4) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <garb2>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p283 + (context ^present lshape4) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <garb2>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p284 + (context ^present lshape4) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <garb2>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy1>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p285 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + - (ff ^grid-x <gx1> ^net-name <> <nn>) + { <v> (vertical ^net-name nil ^min { <vmin1> <= <gy1> } ^max { <vmax1> > <vmin1> >= <gy1> } ^com <gx1> ^layer <lay> ^commo <gx2> ^compo <cpo> ^min-net <vnn1>) } + { <h> (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com { <hcom> >= <vmin1> < <gy1> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (vertical-layer <lay>) + (ff ^grid-x <gx2> ^net-name <> <nn>) + - (horizontal ^net-name nil ^min <= <gx2> ^max >= <gx1> ^com { >= <vmin1> < <hcom> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx1>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx2>) + --> + (remove <c>) + (make vertical ^com <gx1> ^layer <lay> ^min <vmin1> ^max <hcom> ^compo <cpo> ^commo <gx2> ^min-net <vnn1> ^max-net <nn>) + (modify <v> ^min <gy1> ^min-net <nn>) + (make horizontal ^min <hmin> ^max <gx2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <lay> ^min <hcom> ^max <gy1> ^commo <gx2> ^compo <cpo> ^net-name <nn> ^pin-name <pn1>) + (make horizontal ^com <hcom> ^layer <lay> ^min <gx2> ^max <gx1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn1>) + (modify <ff> ^grid-x <gx2> ^grid-y <hcom> ^can-chng-layer nil ^came-from east) + (make context ^present check-for-routed-net) +) + +(p p286 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + - (ff ^grid-x <gx2> ^net-name <> <nn>) + { <v> (vertical ^net-name nil ^min { <vmin1> <= <gy2> } ^max { <vmax1> > <vmin1> >= <gy2> } ^com <gx2> ^layer <lay> ^commo <cmo> ^compo <gx1> ^max-net <vnn1>) } + { <h> (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com { <hcom> <= <vmax1> > <gy2> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (vertical-layer <lay>) + (ff ^grid-x <gx1> ^net-name <> <nn>) + - (horizontal ^net-name nil ^min <= <gx2> ^max >= <gx1> ^com { <= <vmax1> > <hcom> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx2>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx1>) + --> + (remove <c>) + (make vertical ^com <gx2> ^layer <lay> ^min <hcom> ^max <vmax1> ^compo <gx1> ^commo <cmo> ^max-net <vnn1> ^min-net <nn>) + (modify <v> ^max <gy2> ^max-net <nn>) + (make horizontal ^min <hmin> ^max <gx2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <lay> ^max <hcom> ^min <gy2> ^commo <cmo> ^compo <gx1> ^net-name <nn> ^pin-name <pn2>) + (make horizontal ^com <hcom> ^layer <lay> ^min <gx2> ^max <gx1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn2>) + (modify <ff> ^grid-x <gx1> ^grid-y <hcom> ^can-chng-layer nil ^came-from west) + (make context ^present check-for-routed-net) +) + +(p p287 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + - (ff ^grid-x <gx1> ^net-name <> <nn>) + { <v> (vertical ^net-name nil ^min { <vmin1> <= <gy1> } ^max { <vmax1> > <vmin1> >= <gy1> } ^com <gx1> ^layer <lay> ^commo <cmo> ^compo <gx2> ^min-net <vnn1>) } + { <h> (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com { <hcom> >= <vmin1> < <gy1> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (vertical-layer <lay>) + (ff ^grid-x <gx2> ^net-name <> <nn>) + - (horizontal ^net-name nil ^min <= <gx1> ^max >= <gx2> ^com { >= <vmin1> < <hcom> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx1>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx2>) + --> + (remove <c>) + (make vertical ^com <gx1> ^layer <lay> ^min <vmin1> ^max <hcom> ^compo <gx2> ^commo <cmo> ^min-net <vnn1> ^max-net <nn>) + (modify <v> ^min <gy1> ^min-net <nn>) + (make horizontal ^min <hmin> ^max <gx1> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <lay> ^min <hcom> ^max <gy1> ^commo <cmo> ^compo <gx2> ^net-name <nn> ^pin-name <pn1>) + (make horizontal ^com <hcom> ^layer <lay> ^min <gx1> ^max <gx2> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn1>) + (modify <ff> ^grid-x <gx2> ^grid-y <hcom> ^can-chng-layer nil ^came-from west) + (make context ^present check-for-routed-net) +) + +(p p288 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + - (ff ^grid-x <gx2> ^net-name <> <nn>) + { <v> (vertical ^net-name nil ^min { <vmin1> <= <gy2> } ^max { <vmax1> > <vmin1> >= <gy2> } ^com <gx2> ^layer <lay> ^commo <gx1> ^compo <cpo> ^max-net <vnn1>) } + { <h> (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com { <hcom> <= <vmax1> > <gy2> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (vertical-layer <lay>) + (ff ^grid-x <gx1> ^net-name <> <nn>) + - (horizontal ^net-name nil ^min <= <gx1> ^max >= <gx2> ^com { <= <vmax1> > <hcom> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx2>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx1>) + --> + (remove <c>) + (make vertical ^com <gx2> ^layer <lay> ^min <hcom> ^max <vmax1> ^compo <cpo> ^commo <gx1> ^max-net <vnn1> ^min-net <nn>) + (modify <v> ^max <gy2> ^max-net <nn>) + (make horizontal ^min <hmin> ^max <gx1> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <lay> ^max <hcom> ^min <gy2> ^commo <gx1> ^compo <cpo> ^net-name <nn> ^pin-name <pn2>) + (make horizontal ^com <hcom> ^layer <lay> ^min <gx1> ^max <gx2> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn2>) + (modify <ff> ^grid-x <gx1> ^grid-y <hcom> ^can-chng-layer nil ^came-from east) + (make context ^present check-for-routed-net) +) + +(p p289 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + - (ff ^grid-y <gy1> ^net-name <> <nn>) + { <v> (horizontal ^net-name nil ^min { <vmin1> <= <gx1> } ^max { <vmax1> > <vmin1> >= <gx1> } ^com <gy1> ^layer <lay> ^commo <gy2> ^compo <cpo> ^min-net <vnn1>) } + { <h> (vertical ^net-name nil ^min { <hmin> <= <gy2> } ^max { <hmax> > <hmin> >= <gy1> } ^com { <hcom> >= <vmin1> < <gx1> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (horizontal-layer <lay>) + (ff ^grid-y <gy2> ^net-name <> <nn>) + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com { >= <vmin1> < <hcom> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy1>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy2>) + --> + (remove <c>) + (make horizontal ^com <gy1> ^layer <lay> ^min <vmin1> ^max <hcom> ^compo <cpo> ^commo <gy2> ^min-net <vnn1> ^max-net <nn>) + (modify <v> ^min <gx1> ^min-net <nn>) + (make vertical ^min <hmin> ^max <gy2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <lay> ^min <hcom> ^max <gx1> ^commo <gy2> ^compo <cpo> ^net-name <nn> ^pin-name <pn1>) + (make vertical ^com <hcom> ^layer <lay> ^min <gy2> ^max <gy1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn1>) + (modify <ff> ^grid-y <gy2> ^grid-x <hcom> ^can-chng-layer nil ^came-from north) + (make context ^present check-for-routed-net) +) + +(p p290 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + - (ff ^grid-y <gy2> ^net-name <> <nn>) + { <v> (horizontal ^net-name nil ^min { <vmin1> <= <gx2> } ^max { <vmax1> > <vmin1> >= <gx2> } ^com <gy2> ^layer <lay> ^commo <cmo> ^compo <gy1> ^max-net <vnn1>) } + { <h> (vertical ^net-name nil ^min { <hmin> <= <gy2> } ^max { <hmax> > <hmin> >= <gy1> } ^com { <hcom> <= <vmax1> > <gx2> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (horizontal-layer <lay>) + (ff ^grid-y <gy1> ^net-name <> <nn>) + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com { <= <vmax1> > <hcom> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy2>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy1>) + --> + (remove <c>) + (make horizontal ^com <gy2> ^layer <lay> ^min <hcom> ^max <vmax1> ^compo <gy1> ^commo <cmo> ^max-net <vnn1> ^min-net <nn>) + (modify <v> ^max <gx2> ^max-net <nn>) + (make vertical ^min <hmin> ^max <gy2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <lay> ^max <hcom> ^min <gx2> ^commo <cmo> ^compo <gy1> ^net-name <nn> ^pin-name <pn2>) + (make vertical ^com <hcom> ^layer <lay> ^min <gy2> ^max <gy1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn2>) + (modify <ff> ^grid-y <gy1> ^grid-x <hcom> ^can-chng-layer nil ^came-from south) + (make context ^present check-for-routed-net) +) + +(p p291 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + - (ff ^grid-y <gy1> ^net-name <> <nn>) + { <v> (horizontal ^net-name nil ^min { <vmin1> <= <gx1> } ^max { <vmax1> > <vmin1> >= <gx1> } ^com <gy1> ^layer <lay> ^commo <gy2> ^compo <cpo> ^max-net <vnn1>) } + { <h> (vertical ^net-name nil ^min { <hmin> <= <gy2> } ^max { <hmax> > <hmin> >= <gy1> } ^com { <hcom> <= <vmax1> > <gx1> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (horizontal-layer <lay>) + (ff ^grid-y <gy2> ^net-name <> <nn>) + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com { <= <vmax1> > <hcom> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy1>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy2>) + --> + (remove <c>) + (make horizontal ^com <gy1> ^layer <lay> ^min <hcom> ^max <vmax1> ^compo <cpo> ^commo <gy2> ^max-net <vnn1> ^min-net <nn>) + (modify <v> ^max <gx1> ^max-net <nn>) + (make vertical ^min <hmin> ^max <gy2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <lay> ^min <gx1> ^max <hcom> ^commo <gy2> ^compo <cpo> ^net-name <nn> ^pin-name <pn1>) + (make vertical ^com <hcom> ^layer <lay> ^min <gy2> ^max <gy1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn1>) + (modify <ff> ^grid-y <gy2> ^grid-x <hcom> ^can-chng-layer nil ^came-from north) + (make context ^present check-for-routed-net) +) + +(p p292 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + - (ff ^grid-y <gy2> ^net-name <> <nn>) + { <v> (horizontal ^net-name nil ^min { <vmin1> <= <gx2> } ^max { <vmax1> > <vmin1> >= <gx2> } ^com <gy2> ^layer <lay> ^commo <cmo> ^compo <gy1> ^min-net <vnn1>) } + { <h> (vertical ^net-name nil ^min { <hmin> <= <gy2> } ^max { <hmax> > <hmin> >= <gy1> } ^com { <hcom> >= <vmin1> < <gx2> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (horizontal-layer <lay>) + (ff ^grid-y <gy1> ^net-name <> <nn>) + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com { >= <vmin1> < <hcom> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy2>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy1>) + --> + (remove <c>) + (make horizontal ^com <gy2> ^layer <lay> ^min <vmin1> ^max <hcom> ^compo <gy1> ^commo <cmo> ^min-net <vnn1> ^max-net <nn>) + (modify <v> ^min <gx2> ^min-net <nn>) + (make vertical ^min <hmin> ^max <gy2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <lay> ^max <gx2> ^min <hcom> ^commo <cmo> ^compo <gy1> ^net-name <nn> ^pin-name <pn2>) + (make vertical ^com <hcom> ^layer <lay> ^min <gy2> ^max <gy1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn2>) + (modify <ff> ^grid-y <gy1> ^grid-x <hcom> ^can-chng-layer nil ^came-from south) + (make context ^present check-for-routed-net) +) + +(p p211 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> west ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx> }) + (horizontal ^net-name nil ^min { <min> <= <gx2> } ^max { <max> >= <gx> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <gx> ^max >= <gx>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x >= <gx> ^grid-y < <gy>) + - (ff ^net-name <nn> ^grid-x >= <gx> ^grid-y > <gy>) + --> + (make horizontal ^min <min> ^max (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min <gx> ^min-net <nn>) + (make horizontal ^max <gx> ^min (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> - 1) ^came-from east ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p212 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> south ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> < <gy> }) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { <max> > <min> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x < <gx> ^grid-y >= <gy>) + - (ff ^net-name <nn> ^grid-x > <gx> ^grid-y >= <gy>) + --> + (make vertical ^min <min> ^max (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min <gy> ^min-net <nn>) + (make vertical ^max <gy> ^min (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> - 1) ^came-from north ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p213 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> east ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> }) + (horizontal ^net-name nil ^min { <min> <= <gx> } ^max { <max> > <min> >= <gx2> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max > <gx>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <= <gx> ^grid-y < <gy>) + - (ff ^net-name <nn> ^grid-x <= <gx> ^grid-y > <gy>) + --> + (make horizontal ^max <max> ^min (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max <gx> ^max-net <nn>) + (make horizontal ^min <gx> ^max (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> + 1) ^came-from west ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p214 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> north ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy> }) + (vertical ^net-name nil ^min { <min> <= <gy> } ^max { <max> > <min> >= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x < <gx> ^grid-y <= <gy>) + - (ff ^net-name <nn> ^grid-x > <gx> ^grid-y <= <gy>) + --> + (make vertical ^max <max> ^min (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max <gy> ^max-net <nn>) + (make vertical ^min <gy> ^max (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> + 1) ^came-from south ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p215 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> west ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx> } ^grid-y <= <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx2> } ^max { <max> > <min> >= <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <gx> ^max >= <gx>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y > <gy>) + --> + (make horizontal ^min <min> ^max (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min <gx> ^min-net <nn>) + (make horizontal ^max <gx> ^min (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> - 1) ^came-from east ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p216 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> west ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx> } ^grid-y >= <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx2> } ^max { <max> > <min> >= <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <gx> ^max >= <gx>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y < <gy>) + --> + (make horizontal ^min <min> ^max (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min <gx> ^min-net <nn>) + (make horizontal ^max <gx> ^min (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> - 1) ^came-from east ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p217 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> east ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> } ^grid-y <= <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx> } ^max { <max> > <min> >= <gx2> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max > <gx>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y > <gy>) + --> + (make horizontal ^max <max> ^min (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max <gx> ^max-net <nn>) + (make horizontal ^min <gx> ^max (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> + 1) ^came-from west ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p218 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> east ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> } ^grid-y >= <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx> } ^max { <max> > <min> >= <gx2> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max > <gx>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y < <gy>) + --> + (make horizontal ^max <max> ^min (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max <gx> ^max-net <nn>) + (make horizontal ^min <gx> ^max (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> + 1) ^came-from west ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p219 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> north ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy> } ^grid-x >= <gx>) + (vertical ^net-name nil ^min { <min> <= <gy> } ^max { <max> > <min> >= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <vnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <lay>) + - (ff ^net-name <nn> ^grid-x < <gx>) + --> + (make vertical ^max <max> ^min (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <vnn> ^min-net <nn>) + (modify 4 ^max <gy> ^max-net <nn>) + (make vertical ^min <gy> ^max (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> + 1) ^came-from south ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p220 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> north ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy> } ^grid-x <= <gx>) + (vertical ^net-name nil ^min { <min> <= <gy> } ^max { <max> > <min> >= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <vnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (ff ^net-name <nn> ^grid-x > <gx>) + --> + (make vertical ^max <max> ^min (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <vnn> ^min-net <nn>) + (modify 4 ^max <gy> ^max-net <nn>) + (make vertical ^min <gy> ^max (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> + 1) ^came-from south ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p221 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> south ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> < <gy> } ^grid-x <= <gx>) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { <max> > <min> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <vnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (ff ^net-name <nn> ^grid-x > <gx>) + --> + (make vertical ^min <min> ^max (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <vnn> ^min-net <nn>) + (modify 4 ^min <gy> ^min-net <nn>) + (make vertical ^max <gy> ^min (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> - 1) ^came-from north ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p222 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> north ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> < <gy> } ^grid-x >= <gx>) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { <max> > <min> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <vnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <lay>) + - (ff ^net-name <nn> ^grid-x < <gx>) + --> + (make vertical ^min <min> ^max (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <vnn> ^min-net <nn>) + (modify 4 ^min <gy> ^min-net <nn>) + (make vertical ^max <gy> ^min (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> - 1) ^came-from north ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p223 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gx2> } ^com { <com2> >= <min1> <= <max1> >= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + --> + (make horizontal ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make horizontal ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> + 1) ^grid-y <com2> ^grid-layer <lay> ^came-from west) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p224 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-y { <gy2> > <com1> } ^grid-x <gx>) + (vertical ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gy2> } ^com { <com2> >= <min1> <= <max1> >= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + --> + (make vertical ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make vertical ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> + 1) ^grid-x <com2> ^grid-layer <lay> ^came-from south) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p225 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <gx2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> >= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^max-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + --> + (make horizontal ^max <max2> ^min <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make horizontal ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> - 1) ^grid-y <com2> ^grid-layer <lay> ^came-from east) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p226 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-y { <gy2> < <com1> } ^grid-x <gx>) + (vertical ^net-name nil ^min { <min2> <= <gy2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> >= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^max-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + --> + (make vertical ^max <max2> ^min <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make vertical ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> - 1) ^grid-x <com2> ^grid-layer <lay> ^came-from north) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p227 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gx2> } ^com { <com2> >= <min1> <= <max1> <= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + --> + (make horizontal ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make horizontal ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> + 1) ^grid-y <com2> ^grid-layer <lay> ^came-from west) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p228 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-y { <gy2> > <com1> } ^grid-x <gx>) + (vertical ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gy2> } ^com { <com2> >= <min1> <= <max1> <= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + --> + (make vertical ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make vertical ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> + 1) ^grid-x <com2> ^grid-layer <lay> ^came-from south) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p229 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <gx2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> <= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^max-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^layer <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + --> + (make horizontal ^max <max2> ^min <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make horizontal ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> - 1) ^grid-y <com2> ^grid-layer <lay> ^came-from east) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p230 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy2> < <com1> }) + (vertical ^net-name nil ^min { <min2> <= <gy2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> <= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^max-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + --> + (make vertical ^max <max2> ^min <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make vertical ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> - 1) ^grid-x <com2> ^grid-layer <lay> ^came-from north) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p231 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gx2> } ^com { <com2> >= <min1> <= <max1> >= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (vertical ^net-name nil ^max <min1> ^com <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make horizontal ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make horizontal ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> + 1) ^grid-y <com2> ^grid-layer <lay> ^came-from west) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p232 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gx2> } ^com { <com2> >= <min1> <= <max1> <= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (vertical ^net-name nil ^max <min1> ^com <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make horizontal ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make horizontal ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> + 1) ^grid-y <com2> ^grid-layer <lay> ^came-from west) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p233 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <gx2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> >= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (vertical ^net-name nil ^max <min1> ^com <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make horizontal ^min <com1> ^max <max2> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make horizontal ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> - 1) ^grid-y <com2> ^grid-layer <lay> ^came-from east) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p234 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <gx2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> <= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (vertical ^net-name nil ^max <min1> ^com <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make horizontal ^min <com1> ^max <max2> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make horizontal ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> - 1) ^grid-y <com2> ^grid-layer <lay> ^came-from east) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p235 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy2> > <com1> }) + (vertical ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gy2> } ^com { <com2> >= <min1> <= <max1> >= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (horizontal ^net-name nil ^max <min1> ^com <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make vertical ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make vertical ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> + 1) ^grid-x <com2> ^grid-layer <lay> ^came-from south) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p236 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy2> > <com1> }) + (vertical ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gy2> } ^com { <com2> >= <min1> <= <max1> <= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (horizontal ^net-name nil ^max <min1> ^com <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make vertical ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make vertical ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> + 1) ^grid-x <com2> ^grid-layer <lay> ^came-from south) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p237 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy2> < <com1> }) + (vertical ^net-name nil ^min { <min2> <= <gy2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> >= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (horizontal ^net-name nil ^max <min1> ^com <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make vertical ^min <com1> ^max <max2> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make vertical ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> - 1) ^grid-x <com2> ^grid-layer <lay> ^came-from north) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p238 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy2> < <com1> }) + (vertical ^net-name nil ^min { <min2> <= <gy2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> <= <gx> } ^layer <lay> ^commo <cmo2> ^compo <cpo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (horizontal ^net-name nil ^max <min1> ^com <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make vertical ^min <com1> ^max <max2> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make vertical ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> - 1) ^grid-x <com2> ^grid-layer <lay> ^came-from north) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p239 + (context ^present loose-constraint0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side top) + (vertical ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy> ^com { <vcom> > <gx> } ^layer <garb1> ^compo <garb2> ^commo <garb3> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-y > <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <vcom> ^com <gy>) + (vertical ^net-name nil ^min { <min> < <gy> } ^max >= <gy> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <mn>) + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <gy> ^como <hcmo>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <hcmo> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <hcmo> ^can-chng-layer nil) + (modify 1 ^present propagate-constraint) +) + +(p p240 + (context ^present loose-constraint0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side top) + (vertical ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy> ^com { <vcom> < <gx> } ^layer <garb1> ^compo <garb2> ^commo <garb3> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-y > <gy>) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcom> ^max >= <gx> ^com <gy>) + (vertical ^net-name nil ^min { <min> < <gy> } ^max >= <gy> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <mn>) + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <gy> ^como <hcmo>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <hcmo> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <hcmo> ^can-chng-layer nil) + (modify 1 ^present propagate-constraint) +) + +(p p241 + (context ^present loose-constraint0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from south) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side bottom) + (vertical ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy> ^com { <vcom> > <gx> } ^layer <garb1> ^compo <garb2> ^commo <garb3> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-y < <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <vcom> ^com <gy>) + (vertical ^net-name nil ^min <= <gy> ^max { <max> > <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <hcmo> ^como <gy>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <max> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^max-net <mn> ^min-net <nn>) + (modify 5 ^max <gy> ^max-net <nn>) + (make vertical ^net-name <nn> ^min <gy> ^max <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <hcmo> ^can-chng-layer nil) + (modify 1 ^present propagate-constraint) +) + +(p p242 + (context ^present loose-constraint0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from south) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side bottom) + (vertical ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy> ^com { <vcom> < <gx> } ^layer <garb1> ^compo <garb2> ^commo <garb3> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-y < <gy>) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcom> ^max >= <gx> ^com <gy>) + (vertical ^net-name nil ^min <= <gy> ^max { <max> > <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <hcmo> ^como <gy>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <max> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^max-net <mn> ^min-net <nn>) + (modify 5 ^max <gy> ^max-net <nn>) + (make vertical ^net-name <nn> ^min <gy> ^max <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <hcmo> ^can-chng-layer nil) + (modify 1 ^present propagate-constraint) +) + +(p p243 + (context ^present loose-constraint0) + --> + (modify 1 ^present loose-constraint) +) + +(p p363 + (move-via <nn>) + --> + (remove 1) + (make finally-routed <nn>) +) + +(p p364 + (move-via <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay> ^compo <garb1> ^commo <hcmo> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <hcmo> ^max <hcom> ^com { <vcom> >= <hmin> <= <hmax> } ^layer { <vlay> <> <hlay> }) + (vertical ^net-name nil ^min { <vmin2> <= <hcmo> } ^max { <vmax2> > <vmin2> >= <hcom> } ^com <vcom> ^layer <hlay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (horizontal ^net-name <> <nn> ^min < <vcom> ^max >= <vcom> ^com <hcmo>) + - (vertical ^net-name <> <nn> ^min < <hcmo> ^max <hcmo> ^com <vcom>) + --> + (modify 3 ^max <hcmo>) + (make vertical ^layer <vlay> ^max <hcom> ^min <hcmo> ^com <vcom> ^min-net <nn> ^commo <vcmo> ^compo <vcpo>) + (make vertical ^layer <hlay> ^min <vmin2> ^max <hcmo> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn> ^com <vcom>) + (modify 4 ^min <hcom> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <hlay> ^min <hcmo> ^max <hcom> ^commo <vcmo> ^compo <vcpo> ^com <vcom>) + (remove 1) + (make move-via <nn> <vlay> <vcom> <hcom>) +) + +(p p365 + (move-via <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay> ^compo <garb1> ^commo <hcmo> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <hcmo> ^max <hcom> ^com { <vcom> >= <hmin> <= <hmax> } ^layer { <vlay> <> <hlay> }) + (vertical ^net-name nil ^min { <vmin2> <= <hcmo> } ^max { <vmax2> > <vmin2> >= <hcom> } ^com <vcom> ^layer <hlay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (horizontal ^net-name <> <nn> ^min <= <vcom> ^max > <vcom> ^com <hcmo>) + - (vertical ^net-name <> <nn> ^min < <hcmo> ^max <hcmo> ^com <vcom>) + --> + (modify 3 ^max <hcmo>) + (make vertical ^layer <vlay> ^max <hcom> ^min <hcmo> ^com <vcom> ^min-net <nn> ^commo <vcmo> ^compo <vcpo>) + (make vertical ^layer <hlay> ^min <vmin2> ^max <hcmo> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn> ^com <vcom>) + (modify 4 ^min <hcom> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <hlay> ^min <hcmo> ^max <hcom> ^commo <vcmo> ^compo <vcpo> ^com <vcom>) + (remove 1) + (make move-via <nn> <vlay> <vcom> <hcom>) +) + +(p p366 + (move-via <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay> ^compo <garb1> ^commo <vcmo> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcmo> ^max <vcom> ^com { <hcom> >= <vmin> <= <vmax> } ^layer { <hlay> <> <vlay> }) + (horizontal ^net-name nil ^min { <hmin2> <= <vcmo> } ^max { <hmax2> > <hmin2> >= <vcom> } ^com <hcom> ^layer <vlay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (vertical ^net-name <> <nn> ^min < <hcom> ^max >= <hcom> ^com <vcmo>) + - (horizontal ^net-name <> <nn> ^min < <vcmo> ^max <vcmo> ^com <hcom>) + --> + (modify 3 ^max <vcmo>) + (make horizontal ^layer <hlay> ^max <vcom> ^min <vcmo> ^com <hcom> ^min-net <nn> ^commo <hcmo> ^compo <hcpo>) + (make horizontal ^layer <vlay> ^min <hmin2> ^max <vcmo> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn> ^com <hcom>) + (modify 4 ^min <vcom> ^min-net <nn>) + (make horizotnal ^net-name <nn> ^pin-name <pn> ^layer <vlay> ^min <vcmo> ^max <vcom> ^commo <hcmo> ^compo <hcpo> ^com <hcom>) + (remove 1) + (make move-via <nn> <hlay> <hcom> <vcom>) +) + +(p p367 + (move-via <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay> ^compo <garb1> ^commo <vcmo> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcmo> ^com { <hcom> >= <vmin> <= <vmax> } ^max <vcom> ^layer { <hlay> <> <vlay> }) + (horizontal ^net-name nil ^min { <hmin2> <= <vcmo> } ^max { <hmax2> > <hmin2> >= <vcom> } ^com <hcom> ^layer <vlay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (vertical ^net-name <> <nn> ^min <= <hcom> ^max > <hcom> ^com <vcmo>) + - (horizontal ^net-name <> <nn> ^min < <vcmo> ^max <vcmo> ^com <hcom>) + --> + (modify 3 ^max <vcmo>) + (make horizontal ^layer <hlay> ^max <vcom> ^min <vcmo> ^com <hcom> ^min-net <nn> ^commo <hcmo> ^compo <hcpo>) + (make horizontal ^layer <vlay> ^min <hmin2> ^max <vcmo> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn> ^com <hcom>) + (modify 4 ^min <vcom> ^min-net <nn>) + (make horizotnal ^net-name <nn> ^pin-name <pn> ^layer <vlay> ^min <vcmo> ^max <vcom> ^commo <hcmo> ^compo <hcpo> ^com <hcom>) + (remove 1) + (make move-via <nn> <hlay> <hcom> <vcom>) +) + +(p p368 + (move-via <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay> ^compo <hcpo> ^commo <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <hcom> ^max >= <hcpo> ^com { <vcom> >= <hmin> <= <hmax> } ^layer { <vlay> <> <hlay> }) + (vertical ^net-name nil ^min { <vmin2> <= <hcom> } ^max { <vmax2> > <vmin2> >= <hcpo> } ^com <vcom> ^layer <hlay> ^commo <vcmo> ^compo <vcpo> ^min-net <mn>) + - (horizontal ^net-name <> <nn> ^min < <vcom> ^max >= <vcom> ^com <hcpo>) + - (vertical ^net-name <> <nn> ^min <hcpo> ^max > <hcpo> ^com <vcom>) + --> + (modify 3 ^min <hcpo>) + (make vertical ^layer <vlay> ^min <hcom> ^max <hcpo> ^com <vcom> ^max-net <nn> ^commo <vcmo> ^compo <vcpo>) + (make vertical ^layer <hlay> ^min <vmin2> ^max <hcom> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn> ^com <vcom>) + (modify 4 ^min <hcpo> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <hlay> ^min <hcom> ^max <hcpo> ^commo <vcmo> ^compo <vcpo> ^com <vcom>) + (remove 1) + (make move-via <nn> <vlay> <vcom> <hcom>) +) + +(p p369 + (move-via <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay> ^compo <hcpo> ^commo <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <hcom> ^max >= <hcpo> ^com { <vcom> >= <hmin> <= <hmax> } ^layer { <vlay> <> <hlay> }) + (vertical ^net-name nil ^min { <vmin2> <= <hcom> } ^max { <vmax2> > <vmin2> >= <hcpo> } ^com <vcom> ^layer <hlay> ^commo <vcmo> ^compo <vcpo> ^min-net <mn>) + - (horizontal ^net-name <> <nn> ^min <= <vcom> ^max > <vcom> ^com <hcpo>) + - (vertical ^net-name <> <nn> ^min <hcpo> ^max > <hcpo> ^com <vcom>) + --> + (modify 3 ^min <hcpo>) + (make vertical ^layer <vlay> ^min <hcom> ^max <hcpo> ^com <vcom> ^max-net <nn> ^commo <vcmo> ^compo <vcpo>) + (make vertical ^layer <hlay> ^min <vmin2> ^max <hcom> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn> ^com <vcom>) + (modify 4 ^min <hcpo> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <hlay> ^min <hcom> ^max <hcpo> ^commo <vcmo> ^compo <vcpo> ^com <vcom>) + (remove 1) + (make move-via <nn> <vlay> <vcom> <hcom>) +) + +(p p370 + (move-via <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay> ^compo <vcpo> ^commo <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <vcom> ^max >= <vcpo> ^com { <hcom> >= <vmin> <= <vmax> } ^layer { <hlay> <> <vlay> }) + (horizontal ^net-name nil ^min { <hmin2> <= <vcom> } ^max { <hmax2> > <hmin2> >= <vcpo> } ^com <hcom> ^layer <vlay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (vertical ^net-name <> <nn> ^min < <hcom> ^max >= <hcom> ^com <vcpo>) + - (horizontal ^net-name <> <nn> ^min <vcpo> ^max > <vcpo> ^com <hcom>) + --> + (modify 3 ^min <vcpo>) + (make horizontal ^layer <hlay> ^max <vcpo> ^min <vcom> ^com <hcom> ^max-net <nn> ^commo <hcmo> ^compo <hcpo>) + (make horizontal ^layer <vlay> ^min <hmin2> ^max <vcom> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn> ^com <hcom>) + (modify 4 ^min <vcpo> ^min-net <nn>) + (make horizotnal ^net-name <nn> ^pin-name <pn> ^layer <vlay> ^min <vcom> ^max <vcpo> ^commo <hcmo> ^compo <hcpo> ^com <hcom>) + (remove 1) + (make move-via <nn> <hlay> <hcom> <vcom>) +) + +(p p371 + (move-via <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay> ^compo <vcpo> ^commo <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <vcom> ^max >= <vcpo> ^com { <hcom> >= <vmin> <= <vmax> } ^layer { <hlay> <> <vlay> }) + (horizontal ^net-name nil ^min { <hmin2> <= <vcom> } ^max { <hmax2> > <hmin2> >= <vcpo> } ^com <hcom> ^layer <vlay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (vertical ^net-name <> <nn> ^min <= <hcom> ^max > <hcom> ^com <vcmo>) + - (horizontal ^net-name <> <nn> ^min <vcpo> ^max > <vcpo> ^com <hcom>) + --> + (modify 3 ^min <vcpo>) + (make horizontal ^layer <hlay> ^max <vcpo> ^min <vcom> ^com <hcom> ^max-net <nn> ^commo <hcmo> ^compo <hcpo>) + (make horizontal ^layer <vlay> ^min <hmin2> ^max <vcom> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn> ^com <hcom>) + (modify 4 ^min <vcpo> ^min-net <nn>) + (make horizotnal ^net-name <nn> ^pin-name <pn> ^layer <vlay> ^min <vcom> ^max <vcpo> ^commo <hcmo> ^compo <hcpo> ^com <hcom>) + (remove 1) + (make move-via <nn> <hlay> <hcom> <vcom>) +) + +(p p372 + (move-via <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin1> ^max <vmax1> ^com <vcom1> ^layer <vlay> ^compo <vcpo1> ^commo <vcmo1> ^pin-name <pn1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmax1> ^max <vmax2> ^com { <vcom2> > <vcom1> } ^layer <vlay> ^compo <vcpo2> ^commo <vcmo2> ^pin-name <pn2>) + { <h1> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <vcom1> ^max <vcom2> ^com <vmax1> ^layer { <hlay> <> <vlay> }) } + { <h2> (horizontal ^status nil ^net-name nil ^min { <fmin> <= <vcom1> } ^max { <fmax> >= <vcom2> } ^com <vmax1> ^layer <vlay>) } + - (vertical ^min < <vmax1> ^max >= <vmax1> ^com { > <vcom1> < <vcom2> }) + --> + (remove <h2>) + (modify <h1> ^net-name nil ^pin-name nil ^min-net nil ^max-net nil) + (make (substr <h2> 1 inf) ^max <vcmo1> ^max-net nil) + (make (substr <h2> 1 inf) ^min <vcpo2> ^min-net nil) + (make (substr <h1> 1 inf) ^layer <vlay>) +) + +(p p373 + (move-via <nn> <lay> <x> <y>) + (horizontal ^min <x> ^max <garb1> ^com <y> ^layer <lay> ^min-net <nn> ^max-net <garb2>) + --> + (modify 2 ^min-net nil) +) + +(p p374 + (move-via <nn> <lay> <x> <y>) + (vertical ^min <y> ^max <garb1> ^com <x> ^layer <lay> ^min-net <nn> ^max-net <garb2>) + --> + (modify 2 ^min-net nil) +) + +(p p375 + (move-via <nn> <lay> <x> <y>) + (horizontal ^min <garb1> ^max <x> ^com <y> ^layer <lay> ^min-net <garb2> ^max-net <nn>) + --> + (modify 2 ^max-net nil) +) + +(p p376 + (move-via <nn> <lay> <x> <y>) + (vertical ^min <garb1> ^max <y> ^com <x> ^layer <lay> ^min-net <garb2> ^max-net <nn>) + --> + (modify 2 ^max-net nil) +) + +(p start-dummy + (start) + --> + (write (crlf) | Dummy START, do "loadwm" from "kuh.tmp".| (crlf)) + + + +(make layer-info ^layer-name metal ^layer-order 2) +(make layer-info ^layer-name poly ^layer-order 1) +(make channel ^channel-bottom-left-x 0 ^channel-bottom-left-y 0 ^channel-top-right-x 13 ^channel-top-right-y 5 ^channel-width 5 ^channel-length 13 ^no-of-left-pins 0 ^no-of-right-pins 0 ^no-of-top-pins 12 ^no-of-bottom-pins 12) +(make last-row 4 3) +(make last-col 12 11) +(make pin ^net-name 3 ^external-pin-name 1 ^pin-x 1 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 35 ^external-net-name 3) +(make pin ^net-name 1 ^external-pin-name 2 ^pin-x 2 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 34 ^external-net-name 1) +(make pin ^net-name 5 ^external-pin-name 3 ^pin-x 3 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 33 ^external-net-name 5) +(make pin ^net-name 3 ^external-pin-name 4 ^pin-x 4 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 32 ^external-net-name 3) +(make pin ^net-name 5 ^external-pin-name 5 ^pin-x 5 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 31 ^external-net-name 5) +(make pin ^net-name 2 ^external-pin-name 6 ^pin-x 6 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 30 ^external-net-name 2) +(make pin ^net-name 6 ^external-pin-name 7 ^pin-x 7 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 29 ^external-net-name 6) +(make pin ^net-name 8 ^external-pin-name 8 ^pin-x 8 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 28 ^external-net-name 8) +(make pin ^net-name 9 ^external-pin-name 9 ^pin-x 9 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 27 ^external-net-name 9) +(make pin ^net-name 8 ^external-pin-name 10 ^pin-x 10 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 26 ^external-net-name 8) +(make pin ^net-name 7 ^external-pin-name 11 ^pin-x 11 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 25 ^external-net-name 7) +(make pin ^net-name 9 ^external-pin-name 12 ^pin-x 12 ^pin-y 0 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side bottom ^pin-name 24 ^external-net-name 9) +(make pin ^net-name 2 ^external-pin-name 13 ^pin-x 1 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 6 ^external-net-name 2) +(make pin ^net-name 1 ^external-pin-name 14 ^pin-x 2 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 7 ^external-net-name 1) +(make pin ^net-name 4 ^external-pin-name 15 ^pin-x 3 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 8 ^external-net-name 4) +(make pin ^net-name 5 ^external-pin-name 16 ^pin-x 4 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 9 ^external-net-name 5) +(make pin ^net-name 1 ^external-pin-name 17 ^pin-x 5 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 10 ^external-net-name 1) +(make pin ^net-name 6 ^external-pin-name 18 ^pin-x 6 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 11 ^external-net-name 6) +(make pin ^net-name 7 ^external-pin-name 19 ^pin-x 7 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 12 ^external-net-name 7) +(make pin ^net-name 10 ^external-pin-name 20 ^pin-x 8 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 13 ^external-net-name 10) +(make pin ^net-name 4 ^external-pin-name 21 ^pin-x 9 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 14 ^external-net-name 4) +(make pin ^net-name 9 ^external-pin-name 22 ^pin-x 10 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 15 ^external-net-name 9) +(make pin ^net-name 10 ^external-pin-name 23 ^pin-x 11 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 16 ^external-net-name 10) +(make pin ^net-name 10 ^external-pin-name 24 ^pin-x 12 ^pin-y 5 ^pin-layer poly ^pin-layer-constraint fixed ^pin-channel-side top ^pin-name 17 ^external-net-name 10) +(make net ^net-name 3 ^parent-name 3 ^net-no-of-pins 2 ^net-left-x 1 ^net-left-y 0 ^net-right-x 4 ^net-right-y 0 ^no-of-left-pins 0 ^no-of-right-pins 0 ^no-of-top-pins 0 ^no-of-bottom-pins 2 ^left-most-pin-name 35 ^right-most-pin-name 32 ^bottom-most-pin-name 35 ^top-most-pin-name 35 ^external-net-name 3) +(make to-be-routed ^net-name 3 ^no-of-attached-pins 1) +(make included 3 35) +(make net ^net-name 1 ^parent-name 1 ^net-no-of-pins 3 ^net-left-x 2 ^net-left-y 0 ^net-right-x 5 ^net-right-y 5 ^no-of-left-pins 0 ^no-of-right-pins 0 ^no-of-top-pins 2 ^no-of-bottom-pins 1 ^left-most-pin-name 34 ^right-most-pin-name 10 ^bottom-most-pin-name 34 ^top-most-pin-name 7 ^external-net-name 1) +(make to-be-routed ^net-name 1 ^no-of-attached-pins 1) +(make included 1 34) +(make net ^net-name 5 ^parent-name 5 ^net-no-of-pins 3 ^net-left-x 3 ^net-left-y 0 ^net-right-x 5 ^net-right-y 5 ^no-of-left-pins 0 ^no-of-right-pins 0 ^no-of-top-pins 1 ^no-of-bottom-pins 2 ^left-most-pin-name 33 ^right-most-pin-name 31 ^bottom-most-pin-name 33 ^top-most-pin-name 9 ^external-net-name 5) +(make to-be-routed ^net-name 5 ^no-of-attached-pins 1) +(make included 5 33) +(make net ^net-name 2 ^parent-name 2 ^net-no-of-pins 2 ^net-left-x 1 ^net-left-y 0 ^net-right-x 6 ^net-right-y 5 ^no-of-left-pins 0 ^no-of-right-pins 0 ^no-of-top-pins 1 ^no-of-bottom-pins 1 ^left-most-pin-name 6 ^right-most-pin-name 30 ^bottom-most-pin-name 30 ^top-most-pin-name 6 ^external-net-name 2) +(make to-be-routed ^net-name 2 ^no-of-attached-pins 1) +(make included 2 30) +(make net ^net-name 6 ^parent-name 6 ^net-no-of-pins 2 ^net-left-x 6 ^net-left-y 0 ^net-right-x 7 ^net-right-y 5 ^no-of-left-pins 0 ^no-of-right-pins 0 ^no-of-top-pins 1 ^no-of-bottom-pins 1 ^left-most-pin-name 11 ^right-most-pin-name 29 ^bottom-most-pin-name 29 ^top-most-pin-name 11 ^external-net-name 6) +(make to-be-routed ^net-name 6 ^no-of-attached-pins 1) +(make included 6 29) +(make net ^net-name 8 ^parent-name 8 ^net-no-of-pins 2 ^net-left-x 8 ^net-left-y 0 ^net-right-x 10 ^net-right-y 0 ^no-of-left-pins 0 ^no-of-right-pins 0 ^no-of-top-pins 0 ^no-of-bottom-pins 2 ^left-most-pin-name 28 ^right-most-pin-name 26 ^bottom-most-pin-name 28 ^top-most-pin-name 28 ^external-net-name 8) +(make to-be-routed ^net-name 8 ^no-of-attached-pins 1) +(make included 8 28) +(make net ^net-name 9 ^parent-name 9 ^net-no-of-pins 3 ^net-left-x 9 ^net-left-y 0 ^net-right-x 12 ^net-right-y 5 ^no-of-left-pins 0 ^no-of-right-pins 0 ^no-of-top-pins 1 ^no-of-bottom-pins 2 ^left-most-pin-name 27 ^right-most-pin-name 24 ^bottom-most-pin-name 27 ^top-most-pin-name 15 ^external-net-name 9) +(make to-be-routed ^net-name 9 ^no-of-attached-pins 1) +(make included 9 27) +(make net ^net-name 7 ^parent-name 7 ^net-no-of-pins 2 ^net-left-x 7 ^net-left-y 0 ^net-right-x 11 ^net-right-y 5 ^no-of-left-pins 0 ^no-of-right-pins 0 ^no-of-top-pins 1 ^no-of-bottom-pins 1 ^left-most-pin-name 12 ^right-most-pin-name 25 ^bottom-most-pin-name 25 ^top-most-pin-name 12 ^external-net-name 7) +(make to-be-routed ^net-name 7 ^no-of-attached-pins 1) +(make included 7 25) +(make net ^net-name 4 ^parent-name 4 ^net-no-of-pins 2 ^net-left-x 3 ^net-left-y 5 ^net-right-x 9 ^net-right-y 5 ^no-of-left-pins 0 ^no-of-right-pins 0 ^no-of-top-pins 2 ^no-of-bottom-pins 0 ^left-most-pin-name 8 ^right-most-pin-name 14 ^bottom-most-pin-name 8 ^top-most-pin-name 8 ^external-net-name 4) +(make to-be-routed ^net-name 4 ^no-of-attached-pins 1) +(make included 4 8) +(make net ^net-name 10 ^parent-name 10 ^net-no-of-pins 3 ^net-left-x 8 ^net-left-y 5 ^net-right-x 12 ^net-right-y 5 ^no-of-left-pins 0 ^no-of-right-pins 0 ^no-of-top-pins 3 ^no-of-bottom-pins 0 ^left-most-pin-name 13 ^right-most-pin-name 17 ^bottom-most-pin-name 13 ^top-most-pin-name 13 ^external-net-name 10) +(make to-be-routed ^net-name 10 ^no-of-attached-pins 1) +(make included 10 13) +(make vertical-layer poly 24) +(make horizontal-layer metal 0) +(make congestion ^coordinate 0 ^direction row ^no-of-nets 12 ^como -1) +(make congestion ^coordinate 1 ^direction row ^no-of-nets 12 ^como 0) +(make congestion ^coordinate 2 ^direction row ^no-of-nets 6 ^como 1) +(make congestion ^coordinate 3 ^direction row ^no-of-nets 6 ^como 2) +(make congestion ^coordinate 4 ^direction row ^no-of-nets 12 ^como 3) +(make congestion ^coordinate 5 ^direction row ^no-of-nets 12 ^como 4) +(make congestion ^coordinate 0 ^direction col ^no-of-nets 0 ^como -1) +(make congestion ^coordinate 1 ^direction col ^no-of-nets 2 ^como 0) +(make congestion ^coordinate 2 ^direction col ^no-of-nets 3 ^como 1) +(make congestion ^coordinate 3 ^direction col ^no-of-nets 5 ^como 2) +(make congestion ^coordinate 4 ^direction col ^no-of-nets 5 ^como 3) +(make congestion ^coordinate 5 ^direction col ^no-of-nets 4 ^como 4) +(make congestion ^coordinate 6 ^direction col ^no-of-nets 3 ^como 5) +(make congestion ^coordinate 7 ^direction col ^no-of-nets 3 ^como 6) +(make congestion ^coordinate 8 ^direction col ^no-of-nets 4 ^como 7) +(make congestion ^coordinate 9 ^direction col ^no-of-nets 5 ^como 8) +(make congestion ^coordinate 10 ^direction col ^no-of-nets 4 ^como 9) +(make congestion ^coordinate 11 ^direction col ^no-of-nets 3 ^como 10) +(make congestion ^coordinate 12 ^direction col ^no-of-nets 2 ^como 11) +(make congestion ^coordinate 13 ^direction col ^no-of-nets 0 ^como 12) +(make horizontal ^compo 3 ^com 2 ^min 1 ^max 12 ^commo 1 ^layer metal) +(make horizontal ^compo 3 ^com 2 ^min 1 ^max 12 ^commo 1 ^layer poly) +(make horizontal ^compo 4 ^com 3 ^min 1 ^max 12 ^commo 2 ^layer metal) +(make horizontal ^compo 4 ^com 3 ^min 1 ^max 12 ^commo 2 ^layer poly) +(make vertical ^compo 3 ^com 2 ^min 1 ^max 4 ^commo 1 ^layer metal) +(make vertical ^compo 3 ^com 2 ^min 1 ^max 4 ^commo 1 ^layer poly ^min-net 1 ^max-net 1) +(make vertical ^compo 4 ^com 3 ^min 1 ^max 4 ^commo 2 ^layer metal) +(make vertical ^compo 4 ^com 3 ^min 1 ^max 4 ^commo 2 ^layer poly ^min-net 5 ^max-net 4) +(make vertical ^compo 5 ^com 4 ^min 1 ^max 4 ^commo 3 ^layer metal) +(make vertical ^compo 5 ^com 4 ^min 1 ^max 4 ^commo 3 ^layer poly ^min-net 3 ^max-net 5) +(make vertical ^compo 6 ^com 5 ^min 1 ^max 4 ^commo 4 ^layer metal) +(make vertical ^compo 6 ^com 5 ^min 1 ^max 4 ^commo 4 ^layer poly ^min-net 5 ^max-net 1) +(make vertical ^compo 7 ^com 6 ^min 1 ^max 4 ^commo 5 ^layer metal) +(make vertical ^compo 7 ^com 6 ^min 1 ^max 4 ^commo 5 ^layer poly ^min-net 2 ^max-net 6) +(make vertical ^compo 8 ^com 7 ^min 1 ^max 4 ^commo 6 ^layer metal) +(make vertical ^compo 8 ^com 7 ^min 1 ^max 4 ^commo 6 ^layer poly ^min-net 6 ^max-net 7) +(make vertical ^compo 9 ^com 8 ^min 1 ^max 4 ^commo 7 ^layer metal) +(make vertical ^compo 9 ^com 8 ^min 1 ^max 4 ^commo 7 ^layer poly ^min-net 8 ^max-net 10) +(make vertical ^compo 10 ^com 9 ^min 1 ^max 4 ^commo 8 ^layer metal) +(make vertical ^compo 10 ^com 9 ^min 1 ^max 4 ^commo 8 ^layer poly ^min-net 9 ^max-net 4) +(make vertical ^compo 11 ^com 10 ^min 1 ^max 4 ^commo 9 ^layer metal) +(make vertical ^compo 11 ^com 10 ^min 1 ^max 4 ^commo 9 ^layer poly ^min-net 8 ^max-net 9) +(make vertical ^compo 12 ^com 11 ^min 1 ^max 4 ^commo 10 ^layer metal) +(make vertical ^compo 12 ^com 11 ^min 1 ^max 4 ^commo 10 ^layer poly ^min-net 7 ^max-net 10) +(make horizontal ^compo 2 ^com 1 ^min 1 ^max 12 ^commo 0 ^layer metal) +(make horizontal ^compo 5 ^com 4 ^min 11 ^max 12 ^commo 3 ^layer poly ^min-net 10 ^max-net 10) +(make horizontal ^compo 5 ^com 4 ^min 1 ^max 12 ^commo 3 ^layer metal) +(make vertical ^compo 2 ^com 1 ^min 1 ^max 4 ^commo 0 ^layer poly ^min-net 3 ^max-net 2) +(make vertical ^compo 2 ^com 1 ^min 1 ^max 4 ^commo 0 ^layer metal) +(make vertical ^compo 13 ^com 12 ^min 1 ^max 4 ^commo 11 ^layer poly ^min-net 9 ^max-net 10) +(make vertical ^compo 13 ^com 12 ^min 1 ^max 4 ^commo 11 ^layer metal) +(make vertical ^net-name 3 ^compo 2 ^com 1 ^min 0 ^max 1 ^commo 0 ^layer poly ^pin-name 35) +(make ff ^net-name 3 ^grid-layer poly ^grid-x 1 ^grid-y 1 ^came-from south ^pin-name 35) +(make vertical ^net-name 1 ^compo 3 ^com 2 ^min 0 ^max 1 ^commo 1 ^layer poly ^pin-name 34) +(make ff ^net-name 1 ^grid-layer poly ^grid-x 2 ^grid-y 1 ^came-from south ^pin-name 34) +(make vertical ^net-name 5 ^compo 4 ^com 3 ^min 0 ^max 1 ^commo 2 ^layer poly ^pin-name 33) +(make ff ^net-name 5 ^grid-layer poly ^grid-x 3 ^grid-y 1 ^came-from south ^pin-name 33) +(make vertical ^net-name 3 ^compo 5 ^com 4 ^min 0 ^max 1 ^commo 3 ^layer poly ^pin-name 32) +(make ff ^net-name 3 ^grid-layer poly ^grid-x 4 ^grid-y 1 ^came-from south ^pin-name 32) +(make vertical ^net-name 5 ^compo 6 ^com 5 ^min 0 ^max 1 ^commo 4 ^layer poly ^pin-name 31) +(make ff ^net-name 5 ^grid-layer poly ^grid-x 5 ^grid-y 1 ^came-from south ^pin-name 31) +(make vertical ^net-name 2 ^compo 7 ^com 6 ^min 0 ^max 1 ^commo 5 ^layer poly ^pin-name 30) +(make ff ^net-name 2 ^grid-layer poly ^grid-x 6 ^grid-y 1 ^came-from south ^pin-name 30) +(make vertical ^net-name 6 ^compo 8 ^com 7 ^min 0 ^max 1 ^commo 6 ^layer poly ^pin-name 29) +(make ff ^net-name 6 ^grid-layer poly ^grid-x 7 ^grid-y 1 ^came-from south ^pin-name 29) +(make vertical ^net-name 8 ^compo 9 ^com 8 ^min 0 ^max 1 ^commo 7 ^layer poly ^pin-name 28) +(make ff ^net-name 8 ^grid-layer poly ^grid-x 8 ^grid-y 1 ^came-from south ^pin-name 28) +(make vertical ^net-name 9 ^compo 10 ^com 9 ^min 0 ^max 1 ^commo 8 ^layer poly ^pin-name 27) +(make ff ^net-name 9 ^grid-layer poly ^grid-x 9 ^grid-y 1 ^came-from south ^pin-name 27) +(make vertical ^net-name 8 ^compo 11 ^com 10 ^min 0 ^max 1 ^commo 9 ^layer poly ^pin-name 26) +(make ff ^net-name 8 ^grid-layer poly ^grid-x 10 ^grid-y 1 ^came-from south ^pin-name 26) +(make vertical ^net-name 7 ^compo 12 ^com 11 ^min 0 ^max 1 ^commo 10 ^layer poly ^pin-name 25) +(make ff ^net-name 7 ^grid-layer poly ^grid-x 11 ^grid-y 1 ^came-from south ^pin-name 25) +(make vertical ^net-name 9 ^compo 13 ^com 12 ^min 0 ^max 1 ^commo 11 ^layer poly ^pin-name 24) +(make ff ^net-name 9 ^grid-layer poly ^grid-x 12 ^grid-y 1 ^came-from south ^pin-name 24) +(make vertical ^net-name 2 ^compo 2 ^com 1 ^min 4 ^max 5 ^commo 0 ^layer poly ^pin-name 6) +(make ff ^net-name 2 ^grid-layer poly ^grid-x 1 ^grid-y 4 ^came-from north ^pin-name 6) +(make vertical ^net-name 1 ^compo 3 ^com 2 ^min 4 ^max 5 ^commo 1 ^layer poly ^pin-name 7) +(make ff ^net-name 1 ^grid-layer poly ^grid-x 2 ^grid-y 4 ^came-from north ^pin-name 7) +(make vertical ^net-name 4 ^compo 4 ^com 3 ^min 4 ^max 5 ^commo 2 ^layer poly ^pin-name 8) +(make ff ^net-name 4 ^grid-layer poly ^grid-x 3 ^grid-y 4 ^came-from north ^pin-name 8) +(make vertical ^net-name 5 ^compo 5 ^com 4 ^min 4 ^max 5 ^commo 3 ^layer poly ^pin-name 9) +(make ff ^net-name 5 ^grid-layer poly ^grid-x 4 ^grid-y 4 ^came-from north ^pin-name 9) +(make vertical ^net-name 1 ^compo 6 ^com 5 ^min 4 ^max 5 ^commo 4 ^layer poly ^pin-name 10) +(make ff ^net-name 1 ^grid-layer poly ^grid-x 5 ^grid-y 4 ^came-from north ^pin-name 10) +(make vertical ^net-name 6 ^compo 7 ^com 6 ^min 4 ^max 5 ^commo 5 ^layer poly ^pin-name 11) +(make ff ^net-name 6 ^grid-layer poly ^grid-x 6 ^grid-y 4 ^came-from north ^pin-name 11) +(make vertical ^net-name 7 ^compo 8 ^com 7 ^min 4 ^max 5 ^commo 6 ^layer poly ^pin-name 12) +(make ff ^net-name 7 ^grid-layer poly ^grid-x 7 ^grid-y 4 ^came-from north ^pin-name 12) +(make vertical ^net-name 10 ^compo 9 ^com 8 ^min 4 ^max 5 ^commo 7 ^layer poly ^pin-name 13) +(make ff ^net-name 10 ^grid-layer poly ^grid-x 8 ^grid-y 4 ^came-from north ^pin-name 13) +(make vertical ^net-name 4 ^compo 10 ^com 9 ^min 4 ^max 5 ^commo 8 ^layer poly ^pin-name 14) +(make ff ^net-name 4 ^grid-layer poly ^grid-x 9 ^grid-y 4 ^came-from north ^pin-name 14) +(make vertical ^net-name 9 ^compo 11 ^com 10 ^min 4 ^max 5 ^commo 9 ^layer poly ^pin-name 15) +(make ff ^net-name 9 ^grid-layer poly ^grid-x 10 ^grid-y 4 ^came-from north ^pin-name 15) +(make vertical ^net-name 10 ^compo 12 ^com 11 ^min 4 ^max 5 ^commo 10 ^layer poly ^pin-name 16) +(make ff ^net-name 10 ^grid-layer poly ^grid-x 11 ^grid-y 4 ^came-from north ^pin-name 16) +(make vertical ^net-name 10 ^compo 13 ^com 12 ^min 4 ^max 5 ^commo 11 ^layer poly ^pin-name 17) +(make ff ^net-name 10 ^grid-layer poly ^grid-x 12 ^grid-y 4 ^came-from north ^pin-name 17) +(make horizontal-s ^net-name 3 ^top-count 0 ^com 1 ^min 1 ^max 4 ^bot-count 2 ^id 0 ^sum 2 ^difference -2 ^absolute 2) +(make vertical-s ^net-name 1 ^top-count 1 ^com 2 ^min 1 ^max 4 ^bot-count 0 ^id 1 ^sum 1 ^difference 1 ^absolute 1) +(make horizontal-s ^net-name 1 ^top-count 2 ^com 4 ^min 2 ^max 5 ^bot-count 1 ^id 2 ^sum 3 ^difference 1 ^absolute 1) +(make horizontal-s ^net-name 5 ^top-count 1 ^com 1 ^min 3 ^max 5 ^bot-count 2 ^id 3 ^sum 3 ^difference -1 ^absolute 1) +(make vertical-s ^net-name 5 ^top-count 1 ^com 4 ^min 1 ^max 4 ^bot-count 1 ^id 4 ^sum 2 ^difference 0 ^absolute 0) +(make vertical-s ^net-name 2 ^top-count 1 ^com 1 ^min 1 ^max 4 ^bot-count 1 ^id 5 ^sum 2 ^difference 0 ^absolute 0) +(make horizontal-s ^net-name 2 ^top-count 1 ^com 1 ^min 1 ^max 6 ^bot-count 1 ^id 6 ^sum 2 ^difference 0 ^absolute 0) +(make vertical-s ^net-name 6 ^top-count 1 ^com 6 ^min 1 ^max 4 ^bot-count 0 ^id 7 ^sum 1 ^difference 1 ^absolute 1) +(make horizontal-s ^net-name 6 ^top-count 1 ^com 1 ^min 6 ^max 7 ^bot-count 1 ^id 8 ^sum 2 ^difference 0 ^absolute 0) +(make horizontal-s ^net-name 8 ^top-count 0 ^com 1 ^min 8 ^max 10 ^bot-count 2 ^id 9 ^sum 2 ^difference -2 ^absolute 2) +(make horizontal-s ^net-name 9 ^top-count 1 ^com 1 ^min 9 ^max 12 ^bot-count 2 ^id 10 ^sum 3 ^difference -1 ^absolute 1) +(make vertical-s ^net-name 9 ^top-count 1 ^com 10 ^min 1 ^max 4 ^bot-count 1 ^id 11 ^sum 2 ^difference 0 ^absolute 0) +(make vertical-s ^net-name 7 ^top-count 1 ^com 7 ^min 1 ^max 4 ^bot-count 0 ^id 12 ^sum 1 ^difference 1 ^absolute 1) +(make horizontal-s ^net-name 7 ^top-count 1 ^com 1 ^min 7 ^max 11 ^bot-count 1 ^id 13 ^sum 2 ^difference 0 ^absolute 0) +(make horizontal-s ^net-name 4 ^top-count 2 ^com 4 ^min 3 ^max 9 ^bot-count 0 ^id 14 ^sum 2 ^difference 2 ^absolute 2) +(make horizontal-s ^net-name 10 ^top-count 3 ^com 4 ^min 8 ^max 12 ^bot-count 0 ^id 15 ^sum 3 ^difference 3 ^absolute 3) +(make branch-no 1000) +(make context ^present separate) +) diff --git a/contrib/ops/pp.ops b/contrib/ops/pp.ops new file mode 100644 index 000000000..1fe316ec6 --- /dev/null +++ b/contrib/ops/pp.ops @@ -0,0 +1,53 @@ +; Production pretty printer. +; The program takes productions in any lousy +; format and attempts to print them properly. + +(declare (special pcount oport cinp)) + +(defun pp (ifile ofile) + (prog (iport) + (setq iport (infile ifile)) + (setq oport (outfile ofile)) + (setq pcount 1) + (setq cinp (read iport)) + (while cinp + (cond ((atom cinp) (print cinp oport) (terpri oport)) + ((not (equal (car cinp) 'p)) (print cinp oport) + (terpri oport)) + (t (print-prod) (terpri oport))) + (setq cinp (read iport))) + (terpri oport))) + + +(defun print-prod () + (prog nil + (princ "(p " oport) + (print (cadr cinp) oport) (terpri oport) + (setq cinp (cddr cinp)) + (while cinp + (cond ((and (atom (car cinp)) (equal (car cinp) '-->)) + (princ " -->" oport) (terpri oport) + (setq cinp (cdr cinp))) + ((and (atom (car cinp)) (equal (car cinp) '{)) + (princ " " oport) + (print-ce-with-var) (terpri oport)) + ((and (atom (car cinp)) (equal (car cinp) '-)) + (princ " - " oport) + (print (cadr cinp) oport) (terpri oport) + (setq cinp (cddr cinp))) + (t (princ " " oport) + (print (car cinp) oport) (terpri oport) + (setq cinp (cdr cinp))))) + (setq pcount (1+ pcount)) + (princ ")" oport) (terpri oport))) + + +(defun print-ce-with-var () + (prog nil + (while (not (equal (car cinp) '})) + (print (car cinp) oport) (princ " " oport) + (setq cinp (cdr cinp))) + (print (car cinp) oport) + (setq cinp (cdr cinp)))) + + diff --git a/contrib/ops/rubik.ops b/contrib/ops/rubik.ops new file mode 100644 index 000000000..ee615986f --- /dev/null +++ b/contrib/ops/rubik.ops @@ -0,0 +1,2026 @@ + + + +(literalize goal + want + object + number + direction + value + id + seq + status) + +(literalize vodor + right + left + top + bottom + front + posterior + id + status) + +(literalize task-list + task + object + subtask + subtask-object) + +(literalize face + number + block + color) + +(literalize cubie-order + face-num + direction + adj-face-num + block + adj-blk-num) + +(literalize face-relation + front + posterior + right + left + top + bottom) + +(literalize front-face + number + color + id + status) + +(literalize source-face + number + color + ic + id + status) + +(literalize bottom-corner + number + face + color + cubie + id + status) + +(literalize bottom-edge + number + face + color + cubie + id + status) + + + + +(p start + (start) +--> + (remove 1) + (make face ^number 1 ^block 1 ^color blue) + (make face ^number 1 ^block 2 ^color blue) + (make face ^number 1 ^block 3 ^color blue) + (make face ^number 1 ^block 4 ^color blue) + (make face ^number 1 ^block 5 ^color blue) + (make face ^number 1 ^block 6 ^color blue) + (make face ^number 1 ^block 7 ^color blue) + (make face ^number 1 ^block 8 ^color blue) + (make face ^number 1 ^block 9 ^color blue) + (make face ^number 2 ^block 1 ^color red) + (make face ^number 2 ^block 2 ^color red) + (make face ^number 2 ^block 3 ^color red) + (make face ^number 2 ^block 4 ^color red) + (make face ^number 2 ^block 5 ^color red) + (make face ^number 2 ^block 6 ^color red) + (make face ^number 2 ^block 7 ^color red) + (make face ^number 2 ^block 8 ^color red) + (make face ^number 2 ^block 9 ^color red) + (make face ^number 3 ^block 1 ^color green) + (make face ^number 3 ^block 2 ^color green) + (make face ^number 3 ^block 3 ^color green) + (make face ^number 3 ^block 4 ^color green) + (make face ^number 3 ^block 5 ^color green) + (make face ^number 3 ^block 6 ^color green) + (make face ^number 3 ^block 7 ^color green) + (make face ^number 3 ^block 8 ^color green) + (make face ^number 3 ^block 9 ^color green) + (make face ^number 4 ^block 1 ^color white) + (make face ^number 4 ^block 2 ^color white) + (make face ^number 4 ^block 3 ^color white) + (make face ^number 4 ^block 4 ^color white) + (make face ^number 4 ^block 5 ^color white) + (make face ^number 4 ^block 6 ^color white) + (make face ^number 4 ^block 7 ^color white) + (make face ^number 4 ^block 8 ^color white) + (make face ^number 4 ^block 9 ^color white) + (make face ^number 5 ^block 1 ^color yellow) + (make face ^number 5 ^block 2 ^color yellow) + (make face ^number 5 ^block 3 ^color yellow) + (make face ^number 5 ^block 4 ^color yellow) + (make face ^number 5 ^block 5 ^color yellow) + (make face ^number 5 ^block 6 ^color yellow) + (make face ^number 5 ^block 7 ^color yellow) + (make face ^number 5 ^block 8 ^color yellow) + (make face ^number 5 ^block 9 ^color yellow) + (make face ^number 6 ^block 1 ^color orange) + (make face ^number 6 ^block 2 ^color orange) + (make face ^number 6 ^block 3 ^color orange) + (make face ^number 6 ^block 4 ^color orange) + (make face ^number 6 ^block 5 ^color orange) + (make face ^number 6 ^block 6 ^color orange) + (make face ^number 6 ^block 7 ^color orange) + (make face ^number 6 ^block 8 ^color orange) + (make face ^number 6 ^block 9 ^color orange) + (make cubie-order ^face-num 1 ^direction dn + ^adj-face-num 2 ^block 7 ^adj-blk-num 1) + (make cubie-order ^face-num 1 ^direction dn + ^adj-face-num 2 ^block 8 ^adj-blk-num 2) + (make cubie-order ^face-num 1 ^direction dn + ^adj-face-num 2 ^block 9 ^adj-blk-num 3) + (make cubie-order ^face-num 1 ^direction rt + ^adj-face-num 3 ^block 3 ^adj-blk-num 3) + (make cubie-order ^face-num 1 ^direction rt + ^adj-face-num 3 ^block 6 ^adj-blk-num 2) + (make cubie-order ^face-num 1 ^direction rt + ^adj-face-num 3 ^block 9 ^adj-blk-num 1) + (make cubie-order ^face-num 1 ^direction up + ^adj-face-num 4 ^block 1 ^adj-blk-num 3) + (make cubie-order ^face-num 1 ^direction up + ^adj-face-num 4 ^block 2 ^adj-blk-num 2) + (make cubie-order ^face-num 1 ^direction up + ^adj-face-num 4 ^block 3 ^adj-blk-num 1) + (make cubie-order ^face-num 1 ^direction lf + ^adj-face-num 5 ^block 1 ^adj-blk-num 1) + (make cubie-order ^face-num 1 ^direction lf + ^adj-face-num 5 ^block 4 ^adj-blk-num 2) + (make cubie-order ^face-num 1 ^direction lf + ^adj-face-num 5 ^block 7 ^adj-blk-num 3) + (make cubie-order ^face-num 2 ^direction up + ^adj-face-num 1 ^block 1 ^adj-blk-num 7) + (make cubie-order ^face-num 2 ^direction up + ^adj-face-num 1 ^block 2 ^adj-blk-num 8) + (make cubie-order ^face-num 2 ^direction up + ^adj-face-num 1 ^block 3 ^adj-blk-num 9) + (make cubie-order ^face-num 2 ^direction rt + ^adj-face-num 3 ^block 3 ^adj-blk-num 1) + (make cubie-order ^face-num 2 ^direction rt + ^adj-face-num 3 ^block 6 ^adj-blk-num 4) + (make cubie-order ^face-num 2 ^direction rt + ^adj-face-num 3 ^block 9 ^adj-blk-num 7) + (make cubie-order ^face-num 2 ^direction dn + ^adj-face-num 6 ^block 7 ^adj-blk-num 1) + (make cubie-order ^face-num 2 ^direction dn + ^adj-face-num 6 ^block 8 ^adj-blk-num 2) + (make cubie-order ^face-num 2 ^direction dn + ^adj-face-num 6 ^block 9 ^adj-blk-num 3) + (make cubie-order ^face-num 2 ^direction lf + ^adj-face-num 5 ^block 1 ^adj-blk-num 3) + (make cubie-order ^face-num 2 ^direction lf + ^adj-face-num 5 ^block 4 ^adj-blk-num 6) + (make cubie-order ^face-num 2 ^direction lf + ^adj-face-num 5 ^block 7 ^adj-blk-num 9) + (make cubie-order ^face-num 3 ^direction up + ^adj-face-num 1 ^block 1 ^adj-blk-num 9) + (make cubie-order ^face-num 3 ^direction up + ^adj-face-num 1 ^block 2 ^adj-blk-num 6) + (make cubie-order ^face-num 3 ^direction up + ^adj-face-num 1 ^block 3 ^adj-blk-num 3) + (make cubie-order ^face-num 3 ^direction rt + ^adj-face-num 4 ^block 3 ^adj-blk-num 1) + (make cubie-order ^face-num 3 ^direction rt + ^adj-face-num 4 ^block 6 ^adj-blk-num 4) + (make cubie-order ^face-num 3 ^direction rt + ^adj-face-num 4 ^block 9 ^adj-blk-num 7) + (make cubie-order ^face-num 3 ^direction dn + ^adj-face-num 6 ^block 7 ^adj-blk-num 3) + (make cubie-order ^face-num 3 ^direction dn + ^adj-face-num 6 ^block 8 ^adj-blk-num 6) + (make cubie-order ^face-num 3 ^direction dn + ^adj-face-num 6 ^block 9 ^adj-blk-num 9) + (make cubie-order ^face-num 3 ^direction lf + ^adj-face-num 2 ^block 1 ^adj-blk-num 3) + (make cubie-order ^face-num 3 ^direction lf + ^adj-face-num 2 ^block 4 ^adj-blk-num 6) + (make cubie-order ^face-num 3 ^direction lf + ^adj-face-num 2 ^block 7 ^adj-blk-num 9) + (make cubie-order ^face-num 4 ^direction up + ^adj-face-num 1 ^block 1 ^adj-blk-num 3) + (make cubie-order ^face-num 4 ^direction up + ^adj-face-num 1 ^block 2 ^adj-blk-num 2) + (make cubie-order ^face-num 4 ^direction up + ^adj-face-num 1 ^block 3 ^adj-blk-num 1) + (make cubie-order ^face-num 4 ^direction rt + ^adj-face-num 5 ^block 3 ^adj-blk-num 1) + (make cubie-order ^face-num 4 ^direction rt + ^adj-face-num 5 ^block 6 ^adj-blk-num 4) + (make cubie-order ^face-num 4 ^direction rt + ^adj-face-num 5 ^block 9 ^adj-blk-num 7) + (make cubie-order ^face-num 4 ^direction dn + ^adj-face-num 6 ^block 7 ^adj-blk-num 9) + (make cubie-order ^face-num 4 ^direction dn + ^adj-face-num 6 ^block 8 ^adj-blk-num 8) + (make cubie-order ^face-num 4 ^direction dn + ^adj-face-num 6 ^block 9 ^adj-blk-num 7) + (make cubie-order ^face-num 4 ^direction lf + ^adj-face-num 3 ^block 1 ^adj-blk-num 3) + (make cubie-order ^face-num 4 ^direction lf + ^adj-face-num 3 ^block 4 ^adj-blk-num 6) + (make cubie-order ^face-num 4 ^direction lf + ^adj-face-num 3 ^block 7 ^adj-blk-num 9) + (make cubie-order ^face-num 5 ^direction up + ^adj-face-num 1 ^block 1 ^adj-blk-num 1) + (make cubie-order ^face-num 5 ^direction up + ^adj-face-num 1 ^block 2 ^adj-blk-num 4) + (make cubie-order ^face-num 5 ^direction up + ^adj-face-num 1 ^block 3 ^adj-blk-num 7) + (make cubie-order ^face-num 5 ^direction rt + ^adj-face-num 2 ^block 3 ^adj-blk-num 1) + (make cubie-order ^face-num 5 ^direction rt + ^adj-face-num 2 ^block 6 ^adj-blk-num 4) + (make cubie-order ^face-num 5 ^direction rt + ^adj-face-num 2 ^block 9 ^adj-blk-num 7) + (make cubie-order ^face-num 5 ^direction dn + ^adj-face-num 6 ^block 7 ^adj-blk-num 7) + (make cubie-order ^face-num 5 ^direction dn + ^adj-face-num 6 ^block 8 ^adj-blk-num 4) + (make cubie-order ^face-num 5 ^direction dn + ^adj-face-num 6 ^block 9 ^adj-blk-num 1) + (make cubie-order ^face-num 5 ^direction lf + ^adj-face-num 4 ^block 1 ^adj-blk-num 3) + (make cubie-order ^face-num 5 ^direction lf + ^adj-face-num 4 ^block 4 ^adj-blk-num 6) + (make cubie-order ^face-num 5 ^direction lf + ^adj-face-num 4 ^block 7 ^adj-blk-num 9) + (make cubie-order ^face-num 6 ^direction up + ^adj-face-num 2 ^block 1 ^adj-blk-num 7) + (make cubie-order ^face-num 6 ^direction up + ^adj-face-num 2 ^block 2 ^adj-blk-num 8) + (make cubie-order ^face-num 6 ^direction up + ^adj-face-num 2 ^block 3 ^adj-blk-num 9) + (make cubie-order ^face-num 6 ^direction rt + ^adj-face-num 3 ^block 3 ^adj-blk-num 7) + (make cubie-order ^face-num 6 ^direction rt + ^adj-face-num 3 ^block 6 ^adj-blk-num 8) + (make cubie-order ^face-num 6 ^direction rt + ^adj-face-num 3 ^block 9 ^adj-blk-num 9) + (make cubie-order ^face-num 6 ^direction dn + ^adj-face-num 4 ^block 7 ^adj-blk-num 9) + (make cubie-order ^face-num 6 ^direction dn + ^adj-face-num 4 ^block 8 ^adj-blk-num 8) + (make cubie-order ^face-num 6 ^direction dn + ^adj-face-num 4 ^block 9 ^adj-blk-num 7) + (make cubie-order ^face-num 6 ^direction lf + ^adj-face-num 5 ^block 1 ^adj-blk-num 9) + (make cubie-order ^face-num 6 ^direction lf + ^adj-face-num 5 ^block 4 ^adj-blk-num 8) + (make cubie-order ^face-num 6 ^direction lf + ^adj-face-num 5 ^block 7 ^adj-blk-num 7) + (make face-relation ^front 2 ^right 3 ^left 5 + ^top 1 ^bottom 6 ^posterior 4) + (make face-relation ^front 3 ^right 4 ^left 2 + ^top 1 ^bottom 6 ^posterior 5) + (make face-relation ^front 4 ^right 5 ^left 3 + ^top 1 ^bottom 6 ^posterior 2) + (make face-relation ^front 5 ^right 2 ^left 4 + ^top 1 ^bottom 6 ^posterior 3) + (make face-relation ^front 6 ^posterior 1) + (make task-list ^task orient ^object bottom-edge + ^subtask position ^subtask-object bottom-edge) + (make task-list ^task position ^object bottom-edge + ^subtask orient ^subtask-object bottom-corner) + (make task-list ^task orient ^object bottom-corner + ^subtask position ^subtask-object bottom-corner) + (make task-list ^task position ^object bottom-corner + ^subtask orient ^subtask-object vertical-edge) + (make task-list ^task orient ^object vertical-edge + ^subtask position ^subtask-object vertical-edge) + (make task-list ^task position ^object vertical-edge + ^subtask orient ^subtask-object top-corner) + (make task-list ^task orient ^object top-corner + ^subtask position ^subtask-object top-corner) + (make task-list ^task position ^object top-corner + ^subtask orient ^subtask-object top-edge) + (make task-list ^task orient ^object top-edge + ^subtask position ^subtask-object top-edge) + (write (crlf) normal cube order is |:|) + (write (crlf) (tabto 20) top face 1 |:| blue) + (write (crlf) (tabto 20) bottom face 6 |:| orange) + (write (crlf) (tabto 20) front face 2 |:| red) + (write (crlf) (tabto 20) right face 3 |:| green) + (write (crlf) (tabto 20) posterior face 4 |:| white) + (write (crlf) (tabto 20) left face 5 |:| yellow) + (make goal ^want scramble ^object cube ^id 1 ^number nil ^status active)) + +(p scramble*initiate + (goal ^want scramble ^object cube ^id <id> ^number nil ^status active) +--> + (write (crlf) how many scrambling operations >0 shall i perform |?_| ) + (modify 1 ^number (accept))) + +(p scramble*sequence + (goal ^want scramble ^object cube ^id <id> ^number {<n> > 0} + ^status active) +--> + (modify 1 ^number (compute <n> - 1)) + (write (crlf) about which face 1-6 shall i perform this rotation |?_|) + (bind <f> (accept)) + (write (crlf) in which direction pos neg shall i rotate |?_|) + (bind <d> (accept)) + (write (crlf) what size rotation shall i perform 90-180 |?_|) + (bind <v> (accept)) + (make goal ^want rotate ^object face ^number <f> ^direction <d> + ^value <v> ^seq 1 ^status active)) + +(p scramble*exit + (goal ^want scramble ^object cube ^id <id> ^number 0 ^status active) +--> + (remove 1) + (write (crlf) initiating solution |:| (crlf)) + (make goal ^want orient ^object bottom-edge ^id 1 ^status consider)) + + + + +(p sequence-1 + (goal ^want { << orient position >> <w> } ^object <o> + ^id <id> ^status consider) + (task-list ^task <w> ^object <o> ^subtask <st> ^subtask-object <sto>) + -(goal ^want <st> ^object <sto> ^status done) + -(goal ^want rotate ^status active) +--> + (write (crlf) (crlf) suspending task to <w> <o>) + (write (crlf) considering task to <st> <sto>) + (modify 1 ^status pending) + (make goal ^want <st> ^object <sto> ^id (compute <id> + 1) + ^status consider)) + + +(p sequence-2 + (goal ^want { << orient position >> <w> } ^object <o> + ^id <id> ^status consider) + -(task-list ^task <w> ^object <o>) + -(goal ^want rotate ^status active) +--> + (write (crlf) (crlf) initiating task to <w> <o>) + (modify 1 ^status active)) + + +(p sequence-3 + (goal ^want { << orient position >> <w> } ^object <o> + ^id <id> ^status active) + -(goal ^want rotate ^status active) +--> + (write (crlf) (crlf) i find no further tasks to <w> <o>) + (modify 1 ^status done)) + + +(p sequence-4 + (goal ^want { << orient position >> <w> } ^object <o> + ^id <id> ^status pending) + -(goal ^status << active consider >>) + -(goal ^id > <id> ^status pending) +--> + (write (crlf) (crlf) reconsidering task to <w> <o>) + (modify 1 ^status consider)) + +(p sequence-5 + (goal ^want { << orient position >> <w> } ^object <o> + ^id <id> ^status consider) + (task-list ^task <w> ^object <o> ^subtask <st> ^subtask-object <sto>) + (goal ^want <st> ^object <sto> ^status done) + -(goal ^want rotate ^status active) +--> + (write (crlf) (crlf) initiating task to <w> <o>) + (modify 1 ^status active)) + + +(p detect_normal-order + (goal ^want { << orient position >> <w> } ^object <o>) + (face ^number 1 ^block 5 ^color <c1>) + -(face ^number 1 ^block << 1 2 3 4 6 7 8 9 >> ^color <> <c1>) + (face ^number 2 ^block 5 ^color <c2>) + -(face ^number 2 ^block << 1 2 3 4 6 7 8 9 >> ^color <> <c2>) + (face ^number 3 ^block 5 ^color <c3>) + -(face ^number 3 ^block << 1 2 3 4 6 7 8 9 >> ^color <> <c3>) + (face ^number 4 ^block 5 ^color <c4>) + -(face ^number 4 ^block << 1 2 3 4 6 7 8 9 >> ^color <> <c4>) + (face ^number 5 ^block 5 ^color <c5>) + -(face ^number 2 ^block << 1 2 3 4 6 7 8 9 >> ^color <> <c2>) + (face ^number 6 ^block 5 ^color <c6>) + -(face ^number 6 ^block << 1 2 3 4 6 7 8 9 >> ^color <> <c6>) +--> + (write (crlf) i find cube in normal order while attempting to <w> <o>) + (halt)) + + + +(p plus-90 + (goal ^want rotate ^object face ^number <n> ^direction pos + ^value 90 ^id <id> ^seq <seq> ^status active) + -(goal ^want rotate ^object face ^id <id> ^seq < <seq> ^status active) + (face ^number <n> ^block 1 ^color <c1>) + (face ^number <n> ^block 2 ^color <c2>) + (face ^number <n> ^block 3 ^color <c3>) + (face ^number <n> ^block 4 ^color <c4>) + (face ^number <n> ^block 5 ^color <c5>) + (face ^number <n> ^block 6 ^color <c6>) + (face ^number <n> ^block 7 ^color <c7>) + (face ^number <n> ^block 8 ^color <c8>) + (face ^number <n> ^block 9 ^color <c9>) + (cubie-order ^face-num <n> ^direction up ^adj-face-num <nup> + ^block 1 ^adj-blk-num <nup1>) + (cubie-order ^face-num <n> ^direction up ^adj-face-num <nup> + ^block 2 ^adj-blk-num <nup2>) + (cubie-order ^face-num <n> ^direction up ^adj-face-num <nup> + ^block 3 ^adj-blk-num <nup3>) + (cubie-order ^face-num <n> ^direction rt ^adj-face-num <nrt> + ^block 3 ^adj-blk-num <nrt3>) + (cubie-order ^face-num <n> ^direction rt ^adj-face-num <nrt> + ^block 6 ^adj-blk-num <nrt6>) + (cubie-order ^face-num <n> ^direction rt ^adj-face-num <nrt> + ^block 9 ^adj-blk-num <nrt9>) + (cubie-order ^face-num <n> ^direction dn ^adj-face-num <ndn> + ^block 7 ^adj-blk-num <ndn7>) + (cubie-order ^face-num <n> ^direction dn ^adj-face-num <ndn> + ^block 8 ^adj-blk-num <ndn8>) + (cubie-order ^face-num <n> ^direction dn ^adj-face-num <ndn> + ^block 9 ^adj-blk-num <ndn9>) + (cubie-order ^face-num <n> ^direction lf ^adj-face-num <nlf> + ^block 1 ^adj-blk-num <nlf1>) + (cubie-order ^face-num <n> ^direction lf ^adj-face-num <nlf> + ^block 4 ^adj-blk-num <nlf4>) + (cubie-order ^face-num <n> ^direction lf ^adj-face-num <nlf> + ^block 7 ^adj-blk-num <nlf7>) + (face ^number <nrt> ^block <nrt3> ^color <cnrt3>) + (face ^number <nrt> ^block <nrt6> ^color <cnrt6>) + (face ^number <nrt> ^block <nrt9> ^color <cnrt9>) + (face ^number <nlf> ^block <nlf7> ^color <cnlf7>) + (face ^number <nlf> ^block <nlf4> ^color <cnlf4>) + (face ^number <nlf> ^block <nlf1> ^color <cnlf1>) + (face ^number <nup> ^block <nup1> ^color <cnup1>) + (face ^number <nup> ^block <nup2> ^color <cnup2>) + (face ^number <nup> ^block <nup3> ^color <cnup3>) + (face ^number <ndn> ^block <ndn9> ^color <cndn9>) + (face ^number <ndn> ^block <ndn8> ^color <cndn8>) + (face ^number <ndn> ^block <ndn7> ^color <cndn7>) +--> + (write (crlf) rotating face <n> the <c5> face plus 90) + (modify 1 ^status done) + (modify 2 ^color <c7>) + (modify 3 ^color <c4>) + (modify 4 ^color <c1>) + (modify 5 ^color <c8>) + (modify 6 ^color <c5>) + (modify 7 ^color <c2>) + (modify 8. ^color <c9>) + (modify 9. ^color <c6>) + (modify 10. ^color <c3>) + (modify 23. ^color <cnup1>) + (modify 24. ^color <cnup2>) + (modify 25. ^color <cnup3>) + (modify 26. ^color <cndn9>) + (modify 27. ^color <cndn8>) + (modify 28. ^color <cndn7>) + (modify 29. ^color <cnlf7>) + (modify 30. ^color <cnlf4>) + (modify 31. ^color <cnlf1>) + (modify 32. ^color <cnrt3>) + (modify 33. ^color <cnrt6>) + (modify 34. ^color <cnrt9>)) + +(p minus-90 + (goal ^want rotate ^object face ^number <n> ^direction neg + ^value 90 ^id <id> ^seq <seq> ^status active) + -(goal ^want rotate ^object face ^id <id> ^seq < <seq> ^status active) + (face ^number <n> ^block 1 ^color <c1>) + (face ^number <n> ^block 2 ^color <c2>) + (face ^number <n> ^block 3 ^color <c3>) + (face ^number <n> ^block 4 ^color <c4>) + (face ^number <n> ^block 5 ^color <c5>) + (face ^number <n> ^block 6 ^color <c6>) + (face ^number <n> ^block 7 ^color <c7>) + (face ^number <n> ^block 8 ^color <c8>) + (face ^number <n> ^block 9 ^color <c9>) + (cubie-order ^face-num <n> ^direction up ^adj-face-num <nup> + ^block 1 ^adj-blk-num <nup1>) + (cubie-order ^face-num <n> ^direction up ^adj-face-num <nup> + ^block 2 ^adj-blk-num <nup2>) + (cubie-order ^face-num <n> ^direction up ^adj-face-num <nup> + ^block 3 ^adj-blk-num <nup3>) + (cubie-order ^face-num <n> ^direction rt ^adj-face-num <nrt> + ^block 3 ^adj-blk-num <nrt3>) + (cubie-order ^face-num <n> ^direction rt ^adj-face-num <nrt> + ^block 6 ^adj-blk-num <nrt6>) + (cubie-order ^face-num <n> ^direction rt ^adj-face-num <nrt> + ^block 9 ^adj-blk-num <nrt9>) + (cubie-order ^face-num <n> ^direction dn ^adj-face-num <ndn> + ^block 7 ^adj-blk-num <ndn7>) + (cubie-order ^face-num <n> ^direction dn ^adj-face-num <ndn> + ^block 8 ^adj-blk-num <ndn8>) + (cubie-order ^face-num <n> ^direction dn ^adj-face-num <ndn> + ^block 9 ^adj-blk-num <ndn9>) + (cubie-order ^face-num <n> ^direction lf ^adj-face-num <nlf> + ^block 1 ^adj-blk-num <nlf1>) + (cubie-order ^face-num <n> ^direction lf ^adj-face-num <nlf> + ^block 4 ^adj-blk-num <nlf4>) + (cubie-order ^face-num <n> ^direction lf ^adj-face-num <nlf> + ^block 7 ^adj-blk-num <nlf7>) + (face ^number <nrt> ^block <nrt3> ^color <cnrt3>) + (face ^number <nrt> ^block <nrt6> ^color <cnrt6>) + (face ^number <nrt> ^block <nrt9> ^color <cnrt9>) + (face ^number <nlf> ^block <nlf7> ^color <cnlf7>) + (face ^number <nlf> ^block <nlf4> ^color <cnlf4>) + (face ^number <nlf> ^block <nlf1> ^color <cnlf1>) + (face ^number <nup> ^block <nup1> ^color <cnup1>) + (face ^number <nup> ^block <nup2> ^color <cnup2>) + (face ^number <nup> ^block <nup3> ^color <cnup3>) + (face ^number <ndn> ^block <ndn9> ^color <cndn9>) + (face ^number <ndn> ^block <ndn8> ^color <cndn8>) + (face ^number <ndn> ^block <ndn7> ^color <cndn7>) +--> + (write (crlf) rotating face <n> the <c5> face minus 90) + (modify 1 ^status done) + (modify 2 ^color <c3>) + (modify 3 ^color <c6>) + (modify 4 ^color <c9>) + (modify 5 ^color <c2>) + (modify 6 ^color <c5>) + (modify 7 ^color <c8>) + (modify 8. ^color <c1>) + (modify 9. ^color <c4>) + (modify 10. ^color <c7>) + (modify 23. ^color <cndn9>) + (modify 24. ^color <cndn8>) + (modify 25. ^color <cndn7>) + (modify 26. ^color <cnup1>) + (modify 27. ^color <cnup2>) + (modify 28. ^color <cnup3>) + (modify 29. ^color <cnrt3>) + (modify 30. ^color <cnrt6>) + (modify 31. ^color <cnrt9>) + (modify 32. ^color <cnlf7>) + (modify 33. ^color <cnlf4>) + (modify 34. ^color <cnlf1>)) + +(p plus-minus-180 + (goal ^want rotate ^object face ^number <n> + ^direction { << pos neg >> <dir> } ^value 180 ^id <id> ^seq <seq> + ^status active) + -(goal ^want rotate ^object face ^id <id> ^seq < <seq> ^status active) + (face ^number <n> ^block 1 ^color <c1>) + (face ^number <n> ^block 2 ^color <c2>) + (face ^number <n> ^block 3 ^color <c3>) + (face ^number <n> ^block 4 ^color <c4>) + (face ^number <n> ^block 5 ^color <c5>) + (face ^number <n> ^block 6 ^color <c6>) + (face ^number <n> ^block 7 ^color <c7>) + (face ^number <n> ^block 8 ^color <c8>) + (face ^number <n> ^block 9 ^color <c9>) + (cubie-order ^face-num <n> ^direction up ^adj-face-num <nup> + ^block 1 ^adj-blk-num <nup1>) + (cubie-order ^face-num <n> ^direction up ^adj-face-num <nup> + ^block 2 ^adj-blk-num <nup2>) + (cubie-order ^face-num <n> ^direction up ^adj-face-num <nup> + ^block 3 ^adj-blk-num <nup3>) + (cubie-order ^face-num <n> ^direction rt ^adj-face-num <nrt> + ^block 3 ^adj-blk-num <nrt3>) + (cubie-order ^face-num <n> ^direction rt ^adj-face-num <nrt> + ^block 6 ^adj-blk-num <nrt6>) + (cubie-order ^face-num <n> ^direction rt ^adj-face-num <nrt> + ^block 9 ^adj-blk-num <nrt9>) + (cubie-order ^face-num <n> ^direction dn ^adj-face-num <ndn> + ^block 7 ^adj-blk-num <ndn7>) + (cubie-order ^face-num <n> ^direction dn ^adj-face-num <ndn> + ^block 8 ^adj-blk-num <ndn8>) + (cubie-order ^face-num <n> ^direction dn ^adj-face-num <ndn> + ^block 9 ^adj-blk-num <ndn9>) + (cubie-order ^face-num <n> ^direction lf ^adj-face-num <nlf> + ^block 1 ^adj-blk-num <nlf1>) + (cubie-order ^face-num <n> ^direction lf ^adj-face-num <nlf> + ^block 4 ^adj-blk-num <nlf4>) + (cubie-order ^face-num <n> ^direction lf ^adj-face-num <nlf> + ^block 7 ^adj-blk-num <nlf7>) + (face ^number <nrt> ^block <nrt3> ^color <cnrt3>) + (face ^number <nrt> ^block <nrt6> ^color <cnrt6>) + (face ^number <nrt> ^block <nrt9> ^color <cnrt9>) + (face ^number <nlf> ^block <nlf7> ^color <cnlf7>) + (face ^number <nlf> ^block <nlf4> ^color <cnlf4>) + (face ^number <nlf> ^block <nlf1> ^color <cnlf1>) + (face ^number <nup> ^block <nup1> ^color <cnup1>) + (face ^number <nup> ^block <nup2> ^color <cnup2>) + (face ^number <nup> ^block <nup3> ^color <cnup3>) + (face ^number <ndn> ^block <ndn9> ^color <cndn9>) + (face ^number <ndn> ^block <ndn8> ^color <cndn8>) + (face ^number <ndn> ^block <ndn7> ^color <cndn7>) +--> + (write (crlf) rotating face <n> the <c5> face <dir> 180) + (modify 1 ^status done) + (modify 2 ^color <c9>) + (modify 3 ^color <c8>) + (modify 4 ^color <c7>) + (modify 5 ^color <c6>) + (modify 6 ^color <c5>) + (modify 7 ^color <c4>) + (modify 8. ^color <c3>) + (modify 9. ^color <c2>) + (modify 10. ^color <c1>) + (modify 23. ^color <cnlf7>) + (modify 24. ^color <cnlf4>) + (modify 25. ^color <cnlf1>) + (modify 26. ^color <cnrt3>) + (modify 27. ^color <cnrt6>) + (modify 28. ^color <cnrt9>) + (modify 29. ^color <cndn9>) + (modify 30. ^color <cndn8>) + (modify 31. ^color <cndn7>) + (modify 32. ^color <cnup1>) + (modify 33. ^color <cnup2>) + (modify 34. ^color <cnup3>)) + + + +(p position_top_edge*get_defining_faces + (goal ^want position ^object top-edge ^id <id> ^status active) + (face ^number 1 ^block 5 ^color <ct>) + (face ^number { << 2 3 4 5 >> <nf> } ^block 5 ^color <cf>) + -(front-face ^status active) + -(front-face ^number <nf> ^id <id> ^status used) + (face ^number <n1> ^block { << 2 4 6 8 >> <b1> } ^color <ct>) + (face ^number { <n2> <> <n1> } ^block { << 2 4 6 8 >> <b2> } ^color <cf>) + (cubie-order ^face-num <n1> ^adj-face-num <n2> + ^block <b1> ^adj-blk-num <b2>) +--> + (make front-face ^number <nf> ^color <cf> ^id <id> ^status active) + (make source-face ^number <n1> ^color <ct> ^id <id> ^status active) + (make source-face ^number <n2> ^color <cf> ^id <id> ^status active)) + +(p position_top_edge*desired_cubie_in_position + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number 1 ^id <id> ^status active) + (face-relation ^front <nf> ^top 1) +--> + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + + +(p rt-to-ft + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number <nf> ^id <id> ^status active) + (source-face ^number <nr> ^id <id> ^status active) + (source-face ^number {<nt> <> <nr>} ^id <id> ^status active) + (face-relation ^front <nf> ^right <nr>) +--> + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p pt-to-ft + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number <nf> ^id <id> ^status active) + (source-face ^number <np> ^id <id> ^status active) + (source-face ^number {<nt> <> <np>} ^id <id> ^status active) + (face-relation ^front <nf> ^posterior <np> ^right <nr> ^top <nt>) +--> + (make goal ^want rotate ^object face ^number <nt> ^direction pos + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nt> ^direction neg + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 4 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p lt-to-ft + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number <nf> ^id <id> ^status active) + (source-face ^number <nl> ^id <id> ^status active) + (source-face ^number {<nt> <> <nl>} ^id <id> ^status active) + (face-relation ^front <nf> ^left <nl> ^top <nt>) +--> + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 2 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p fr-to-ft + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number <nf> ^id <id> ^status active) + (source-face ^number <nf> ^id <id> ^status active) + (source-face ^number {<nr> <> <nf>} ^id <id> ^status active) + (face-relation ^front <nf> ^right <nr>) +--> + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p pr-to-ft + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number <nf> ^id <id> ^status active) + (source-face ^number <np> ^id <id> ^status active) + (source-face ^number {<nr> <> <np>} ^id <id> ^status active) + (face-relation ^front <nf> ^posterior <np> ^right <nr>) +--> + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 180 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 180 ^id <id> ^seq 3 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p lp-to-ft + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number <nf> ^id <id> ^status active) + (source-face ^number <nl> ^id <id> ^status active) + (source-face ^number {<np> <> <nl>} ^id <id> ^status active) + (face-relation ^front <nf> ^posterior <np> ^left <nl>) +--> + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 180 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 180 ^id <id> ^seq 3 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p fl-to-ft + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number <nf> ^id <id> ^status active) + (source-face ^number <nf> ^id <id> ^status active) + (source-face ^number {<nl> <> <nf>} ^id <id> ^status active) + (face-relation ^front <nf> ^left <nl>) +--> + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 1 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p bf-to-ft + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number <nf> ^id <id> ^status active) + (source-face ^number <nb> ^id <id> ^status active) + (source-face ^number {<nf> <> <nb>} ^id <id> ^status active) + (face-relation ^front <nf> ^bottom <nb>) +--> + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 180 ^id <id> ^seq 1 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p br-to-ft + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number <nf> ^id <id> ^status active) + (source-face ^number <nb> ^id <id> ^status active) + (source-face ^number {<nr> <> <nb>} ^id <id> ^status active) + (face-relation ^front <nf> ^right <nr> ^bottom <nb>) +--> + (make goal ^want rotate ^object face ^number <nb> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 180 ^id <id> ^seq 2 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p bp-to-ft + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number <nf> ^id <id> ^status active) + (source-face ^number <nb> ^id <id> ^status active) + (source-face ^number {<np> <> <nb>} ^id <id> ^status active) + (face-relation ^front <nf> ^posterior <np> ^bottom <nb>) +--> + (make goal ^want rotate ^object face ^number <nb> ^direction pos + ^value 180 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 180 ^id <id> ^seq 2 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p bl-to-ft + (goal ^want position ^object top-edge ^id <id> ^status active) + (front-face ^number <nf> ^id <id> ^status active) + (source-face ^number <nb> ^id <id> ^status active) + (source-face ^number {<nl> <> <nb>} ^id <id> ^status active) + (face-relation ^front <nf> ^left <nl> ^bottom <nb>) +--> + (make goal ^want rotate ^object face ^number <nb> ^direction pos + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 180 ^id <id> ^seq 2 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p orient_top_edge + (goal ^want orient ^object top-edge ^id <id> ^status active) + (face ^number 1 ^block 5 ^color <ct>) + (face ^number { << 2 3 4 5 >> <nf> } ^block 5 ^color <cf>) + (face ^number 1 ^block { << 2 4 6 8 >> <b> } ^color <cf>) + (face ^number <nf> ^block 2 ^color <ct>) + (cubie-order ^face-num <nf> ^direction up + ^adj-face-num 1 ^block 2 ^adj-blk-num <b>) + (face-relation ^front <nf> ^top 1 ^left <nl>) +--> + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number 1 ^direction pos + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number 1 ^direction neg + ^value 90 ^id <id> ^seq 4 ^status active)) + +(p position_top_corner*get_defining_faces + (goal ^want position ^object top-corner ^id <id> ^status active) + -(front-face ^id <id> ^status active) + -(source-face ^id <id> ^status active) + (face ^number 1 ^block 5 ^color <ct>) + (face ^number { << 2 3 4 5 >> <nf> } ^block 5 ^color <cf>) + -(front-face ^number <nf> ^id <id> ^status used) + (face ^number { <nr> <> <nf> <> 1 <> 6 } ^block 5 ^color <cr>) + (face-relation ^front <nf> ^right <nr> ^top 1) + (face ^number <n1> ^block { << 1 3 7 9 >> <b1> } ^color <ct>) + (face ^number { <n2> <> <n1> } ^block { << 1 3 7 9 >> <b2> } ^color <cf>) + (face ^number { <n3> <> <n2> } ^block { << 1 3 7 9 >> <b3> } ^color <cr>) + (cubie-order ^face-num <n1> ^adj-face-num <n2> ^block <b1> + ^adj-blk-num <b2>) + (cubie-order ^face-num <n1> ^adj-face-num <n3> ^block <b1> + ^adj-blk-num <b3>) + (cubie-order ^face-num <n2> ^adj-face-num <n3> ^block <b2> + ^adj-blk-num <b3>) +--> + (make front-face ^number <nf> ^color <cf> ^id <id> ^status active) + (make source-face ^number <n1> ^color <ct> ^id <id> ^status active) + (make source-face ^number <n2> ^color <cf> ^id <id> ^status active) + (make source-face ^number <n3> ^color <cr> ^id <id> ^status active)) + +(p position_top_corner*desired_cubie_in_position + (goal ^want position ^object top-corner ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nt> <> <nf> <> 6} ^id <id> ^status active) + (source-face ^number {<nr> <> <nt> <> <nf> <> 6} ^id <id> ^status active) + (face-relation ^front <nf> ^right <nr> ^top <nt>) +--> + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used) + (modify 5 ^status used)) + +(p position_top_corner*desired_cubie_on_left_front_top + (goal ^want position ^object top-corner ^id <id> ^status active) + (front-face ^number {<n3> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number 1 ^id <id> ^status active) + (source-face ^number {<n2> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<n3> <> <n2> <> 1 <> 6} ^id <id> ^status active) + (face-relation ^front {<n2> <> 1 <> 6} ^posterior <n4> ^right <n3> ^top 1) +--> + (make goal ^want rotate ^object face ^number <n3> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <n3> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 180 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number <n4> ^direction neg + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number <n4> ^direction pos + ^value 90 ^id <id> ^seq 7 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used) + (modify 5 ^status used)) + +(p position_top_corner*desired_cubie_on_top_right_posterior + (goal ^want position ^object top-corner ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number 1 ^id <id> ^status active) + (source-face ^number {<n2> <> <nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<n3> <> <n2> <> 1 <> 6} ^id <id> ^status active) + (face-relation ^front {<n2> <> 1 <> 6} ^right {<n3> <> 1 <> 6} ^top 1) + (face-relation ^front {<nf> <> 1 <> 6} ^right {<n2> <> 1 <> 6} ^top 1) +--> + (make goal ^want rotate ^object face ^number <n3> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <n3> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <n2> ^direction neg + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <n2> ^direction pos + ^value 90 ^id <id> ^seq 6 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used) + (modify 5 ^status used)) + +(p position_top_corner*desired_cubie_on_top_left_posterior + (goal ^want position ^object top-corner ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number 1 ^id <id> ^status active) + (source-face ^number {<n2> <> <nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<n3> <> <n2> <> 1 <> 6} ^id <id> ^status active) + (face-relation ^front {<n2> <> <nf>} ^right {<n3> <> <nf>} ^top 1) + (face-relation ^front <nf> ^right <n4> ^left <n3> ^top 1) +--> + (make goal ^want rotate ^object face ^number <n3> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 180 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <n3> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <n4> ^direction neg + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <n4> ^direction pos + ^value 90 ^id <id> ^seq 6 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used) + (modify 5 ^status used)) + +(p position_top_corner*desired_cubie_under_desired_position + (goal ^want position ^object top-corner ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nr> <> <nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number 6 ^id <id> ^status active) + (face-relation ^front <nf> ^right <nr> ^bottom 6) +--> + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used) + (modify 5 ^status used)) + +(p position_top_corner*desired_cubie_on_bottom_left_front + (goal ^want position ^object top-corner ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nl> <> <nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number 6 ^id <id> ^status active) + (face-relation ^front <nl> ^posterior <np> ^right <nf> ^bottom 6) +--> + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <np> ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <np> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used) + (modify 5 ^status used)) + +(p position_top_corner*desired_cubie_on_bottom_left_posterior + (goal ^want position ^object top-corner ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nl> <> <nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<np> <> <nl> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number 6 ^id <id> ^status active) + (face-relation ^front <nf> ^posterior <np> ^right <nr> + ^left <nl> ^bottom 6) +--> + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 180 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used) + (modify 5 ^status used)) + +(p position_top_corner*desired_cubie_on_bottom_right_posterior + (goal ^want position ^object top-corner ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nr> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<np> <> <nr> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number 6 ^id <id> ^status active) + (face-relation ^front <nf> ^posterior <np> ^right <nr> ^bottom 6) +--> + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used) + (modify 5 ^status used)) + +(p orient_top_corner + (goal ^want orient ^object top-corner ^id <id> ^status active) + (face ^number 1 ^block 5 ^color <ct>) + (face ^number { << 2 3 4 5 >> <nf> } ^block 5 ^color <cf>) + (face ^number { <nr> <> <nf> <> 1 <> 6 } ^block 5 ^color <cr>) + (face-relation ^front <nf> ^right <nr> ^top 1 ^bottom 6) + (face ^number <nf> ^block 3 ^color <> <cf>) +--> + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 180 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 180 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 6 ^status active)) + +(p position_vertical_edge*get_defining_faces + (goal ^want position ^object vertical-edge ^id <id> ^status active) + -(source-face ^id <id> ^status active) + (face ^number { << 2 3 4 5 >> <nf> } ^block 5 ^color <cf>) + -(front-face ^number <nf> ^id <id> ^status used) + (face ^number { <nr> <> <nf> <> 1 <> 6 } ^block 5 ^color <cr>) + (face-relation ^front <nf> ^right <nr> ^top 1 ^bottom 6) + (face ^number {<n1> <> 1} ^block { << 2 4 6 8 >> <b1> } ^color <cf>) + (face ^number {<n2> <> <n1> <> 1} ^block { << 2 4 6 8 >> <b2> } + ^color <cr>) + (cubie-order ^face-num <n1> ^adj-face-num <n2> + ^block <b1> ^adj-blk-num <b2>) +--> + (make front-face ^number <nf> ^color <cf> ^id <id> ^status active) + (make source-face ^number <n1> ^color <cf> ^id <id> ^status active) + (make source-face ^number <n2> ^color <cr> ^id <id> ^status active)) + +(p position_vertical_edge*desired_cube_in_position + (goal ^want position ^object vertical-edge ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nr> <> <nf> <> 1 <> 6} ^id <id> ^status active) + (face-relation ^front <nf> ^right <nr> ^top 1) +--> + (modify 2 ^status used) + (modify 3 ^status used) + (modify 4 ^status used)) + +(p position_vertical_edge*fr-to-bp + (goal ^want position ^object vertical-edge ^id <id> ^status active) + (front-face ^number {<n1> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number {<nr> <> <nf> <> 1 <> 6} ^id <id> + ^status active) + (face-relation ^front <nf> ^posterior <np> ^right <nr> ^bottom 6) + -(face-relation ^front <n1> ^right <nr> ^bottom 6) +--> + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 7 ^status active) + (modify 3 ^number 6) + (modify 4 ^number <np>)) + +(p position_vertical_edge*try_bottom_rotation + (goal ^want position ^object vertical-edge ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (source-face ^number { << 2 3 4 5 >> <ns> } ^color <cs> + ^id <id>^status active) + (face ^number <ns> ^block 5 ^color <> <cs>) + (source-face ^number 6 ^id <id> ^status active) + (face-relation ^front <ns> ^right <nsr> ^bottom 6) +--> + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 1 ^status active) + (modify 3 ^number <nsr>)) + +(p position_vertical_edge*match_on_f-face + (goal ^want position ^object vertical-edge ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (face-relation ^front <nf> ^right <nr> ^bottom 6) + (face ^number <nf> ^block 5 ^color <cf>) + (face ^number <nf> ^block 8 ^color <cf>) + (face ^number <nr> ^block 5 ^color <cr>) + (source-face ^number {<nf> <> 1 <> 6} ^color <cf> ^id <id> ^status active) + (source-face ^number 6 ^color <cr> ^id <id> ^status active) +--> + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 7 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 8 ^status active) + (modify 2 ^status used) + (modify 7 ^status used) + (modify 8 ^status used)) + +(p position_vertical_edge*match_on_r-face + (goal ^want position ^object vertical-edge ^id <id> ^status active) + (front-face ^number {<nf> <> 1 <> 6} ^id <id> ^status active) + (face-relation ^front <nf> ^right <nr> ^bottom 6) + (face ^number <nf> ^block 5 ^color <cf>) + (face ^number <nr> ^block 5 ^color <cr>) + (face ^number <nr> ^block 8 ^color <cr>) + (source-face ^number {<nr> <> 1 <> 6} ^color <cr> ^id <id> ^status active) + (source-face ^number 6 ^color <cf> ^id <id> ^status active) +--> + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 7 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 8 ^status active) + (modify 2 ^status used) + (modify 7 ^status used) + (modify 8 ^status used)) + +(p orient_vertical_edge + (goal ^want orient ^object vertical-edge ^id <id> ^status active) + (face ^number { << 2 3 4 5 >> <nf> } ^block 5 ^color <cf>) + (face ^number { <nr> <> <nf> <> 1 <> 6 } ^block 5 ^color <cr>) + (face ^number <nf> ^block 6 ^color <cr>) + (face ^number <nr> ^block 4 ^color <cf>) + (cubie-order ^face-num <nf> ^direction rt + ^adj-face-num <nr> ^block 6 ^adj-blk-num 4) + (face-relation ^front <nf> ^top 1 ^right <nr>) +--> + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 7 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 8 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 9 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 10 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 11 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 12 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 13 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 14 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 15 ^status active)) + +(p position_bottom_corner + (goal ^want position ^object bottom-corner ^id <id> ^status active) + -(bottom-corner ^id <id> ^status << active done >>) + -(goal ^want clean-up ^object bottom-corner ^id <id> ^status active) + (face ^number 2 ^block 9 ^color <c29>) + (face ^number 3 ^block 7 ^color <c37>) + (cubie-order ^face-num 2 ^direction dn ^adj-face-num 6 + ^block 9 ^adj-blk-num <blk269>) + (face ^number 6 ^block <blk269> ^color <c269>) + (face ^number 3 ^block 9 ^color <c39>) + (face ^number 4 ^block 7 ^color <c47>) + (cubie-order ^face-num 3 ^direction dn ^adj-face-num 6 + ^block 9 ^adj-blk-num <blk369>) + (face ^number 6 ^block <blk369> ^color <c369>) + (face ^number 4 ^block 9 ^color <c49>) + (face ^number 5 ^block 7 ^color <c57>) + (cubie-order ^face-num 4 ^direction dn ^adj-face-num 6 + ^block 9 ^adj-blk-num <blk469>) + (face ^number 6 ^block <blk469> ^color <c469>) + (face ^number 5 ^block 9 ^color <c59>) + (face ^number 2 ^block 7 ^color <c27>) + (cubie-order ^face-num 5 ^direction dn ^adj-face-num 6 + ^block 9 ^adj-blk-num <blk569>) + (face ^number 6 ^block <blk569> ^color <c569>) +--> + (make bottom-corner ^number 1 ^face 2 ^color <c29> + ^id <id> ^status active) + (make bottom-corner ^number 1 ^face 3 ^color <c37> + ^id <id> ^status active) + (make bottom-corner ^number 1 ^face 6 ^color <c269> + ^id <id> ^status active) + (make bottom-corner ^number 2 ^face 3 ^color <c39> + ^id <id> ^status active) + (make bottom-corner ^number 2 ^face 4 ^color <c47> + ^id <id> ^status active) + (make bottom-corner ^number 2 ^face 6 ^color <c369> + ^id <id> ^status active) + (make bottom-corner ^number 3 ^face 4 ^color <c49> + ^id <id> ^status active) + (make bottom-corner ^number 3 ^face 5 ^color <c57> + ^id <id> ^status active) + (make bottom-corner ^number 3 ^face 6 ^color <c469> + ^id <id> ^status active) + (make bottom-corner ^number 4 ^face 5 ^color <c59> + ^id <id> ^status active) + (make bottom-corner ^number 4 ^face 2 ^color <c27> + ^id <id> ^status active) + (make bottom-corner ^number 4 ^face 6 ^color <c569> + ^id <id> ^status active)) + +(p position_bottom_corner*find_no_match + (goal ^want position ^object bottom-corner ^id <id> ^status active) + -(goal ^want clean-up ^object bottom-corner ^id <id> ^status active) + -(goal ^want rotate ^object face ^number 6 ^id <id> ^status active) + (bottom-corner ^number 1 ^face 2 ^id <id> ^status active) +--> + (make goal ^want clean-up ^object bottom-corner ^id <id> ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 1 ^status active)) + +(p position_bottom_corner*clean_up_bottom_corner + (goal ^want position ^object bottom-corner ^id <id> ^status active) + (goal ^want clean-up ^object bottom-corner ^id <id> ^status active) + -(goal ^want rotate ^object face ^id <id> ^status active) + (bottom-corner ^id <id> ^status active) +--> + (modify 3 ^status used)) + +(p position_bottom_corner*clean_up_bottom_corner*exit + (goal ^want position ^object bottom-corner ^id <id> ^status active) + (goal ^want clean-up ^object bottom-corner ^id <id> ^status active) + -(goal ^want rotate ^object face ^id <id> ^status active) + -(bottom-corner ^id <id> ^status active) +--> + (remove 2)) + +(p position_bottom_corner*find_one_match + (goal ^want position ^object bottom-corner ^id <id> ^status active) + -(goal ^want clean-up ^object bottom-corner ^id <id> ^status active) + -(goal ^want rotate ^object face ^number 6 ^id <id> ^status active) + -(bottom-corner ^id <id> ^status done) + (face ^number <nf> ^block 5 ^color <cf>) + (face ^number <nr> ^block 5 ^color <cr>) + (face ^number <nb> ^block 5 ^color <cb>) + (face-relation ^front <nf> ^right <nr> ^bottom <nb>) + (bottom-corner ^number <n1> ^color <cf> ^status active) + (bottom-corner ^number <n1> ^color <cr> ^status active) + (bottom-corner ^number <n1> ^color <cb> ^status active) + (bottom-corner ^number <n1> ^face <nf> ^status active) + (bottom-corner ^number <n1> ^face <nr> ^status active) + (bottom-corner ^number <n1> ^face <nb> ^status active) +--> + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want clean-up ^object bottom-corner ^id <id> ^status active)) + +(p position_bottom_corner*exchange_two_adjacent + (goal ^want position ^object bottom-corner ^id <id> ^status active) + -(goal ^want clean-up ^object bottom-corner ^id <id> ^status active) + -(goal ^want rotate ^object face ^number 6 ^id <id> ^status active) + -(bottom-corner ^id <id> ^status done) + (face ^number <nf> ^block 5 ^color <cf>) + (face ^number <nl> ^block 5 ^color <cl>) + (face ^number <nb> ^block 5 ^color <cb>) + (face-relation ^front <nf> ^posterior <np> ^left <nl> ^right <nr> + ^bottom <nb>) + (bottom-corner ^number <n1> ^color <cf> ^status active) + (bottom-corner ^number <n1> ^color <cl> ^status active) + (bottom-corner ^number <n1> ^color <cb> ^status active) + (bottom-corner ^number <n1> ^face <nf> ^status active) + (bottom-corner ^number <n1> ^face <nl> ^status active) + (bottom-corner ^number <n1> ^face <nb> ^status active) + (face ^number <nf> ^block 5 ^color <cf>) + (face ^number <nr> ^block 5 ^color <cr>) + (bottom-corner ^number {<n2> <> <n1>} ^color <cf> ^status active) + (bottom-corner ^number <n2> ^color <cr> ^status active) + (bottom-corner ^number <n2> ^color <cb> ^status active) + (bottom-corner ^number <n2> ^face <nf> ^status active) + (bottom-corner ^number <n2> ^face <nr> ^status active) + (bottom-corner ^number <n2> ^face <nb> ^status active) +--> + (make bottom-corner ^id <id> ^status done) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <np> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <np> ^direction neg + ^value 90 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 7 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 8 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 9 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 180 ^id <id> ^seq 10 ^status active) + (make goal ^want clean-up ^object bottom-corner ^id <id> ^status active)) + +(p position_bottom_corner*exchange_two_diagonal + (goal ^want position ^object bottom-corner ^id <id> ^status active) + -(goal ^want clean-up ^object bottom-corner ^id <id> ^status active) + -(goal ^want rotate ^object face ^number 6 ^id <id> ^status active) + -(bottom-corner ^id <id> ^status done) + (face ^number <nf> ^block 5 ^color <cf>) + (face ^number <nl> ^block 5 ^color <cl>) + (face ^number <nb> ^block 5 ^color <cb>) + (face-relation ^front <nf> ^posterior <np> ^left <nl> ^right <nr> + ^bottom <nb>) + (bottom-corner ^number <n1> ^color <cf> ^status active) + (bottom-corner ^number <n1> ^color <cl> ^status active) + (bottom-corner ^number <n1> ^color <cb> ^status active) + (bottom-corner ^number <n1> ^face <nf> ^status active) + (bottom-corner ^number <n1> ^face <nl> ^status active) + (bottom-corner ^number <n1> ^face <nb> ^status active) + (face ^number <nr> ^block 5 ^color <cr>) + (face ^number <np> ^block 5 ^color <cp>) + (face-relation ^front <nr> ^right <np> ^bottom <nb>) + (bottom-corner ^number {<n2> > <n1>} ^color <cr> ^status active) + (bottom-corner ^number <n2> ^color <cp> ^status active) + (bottom-corner ^number <n2> ^color <cb> ^status active) + (bottom-corner ^number <n2> ^face <nr> ^status active) + (bottom-corner ^number <n2> ^face <np> ^status active) + (bottom-corner ^number <n2> ^face <nb> ^status active) +--> + (make bottom-corner ^id <id> ^status done) + (make goal ^want rotate ^object face ^number <np> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <np> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 180 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number <np> ^direction neg + ^value 90 ^id <id> ^seq 7 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 8 ^status active) + (make goal ^want rotate ^object face ^number <np> ^direction pos + ^value 90 ^id <id> ^seq 9 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 10 ^status active) + (make goal ^want clean-up ^object bottom-corner ^id <id> ^status active)) + +(p position_bottom_corner*match_four + (goal ^want position ^object bottom-corner ^id <id> ^status active) + -(goal ^want clean-up ^object bottom-corner ^id <id> ^status active) + -(goal ^want rotate ^object face ^number 6 ^id <id> ^status active) + -(bottom-corner ^id <id> ^status done) + (face ^number <n1f> ^block 5 ^color <c1f>) + (face ^number <n1r> ^block 5 ^color <c1r>) + (face ^number <nb> ^block 5 ^color <c1b>) + (face-relation ^front <n1f> ^right <n1r> ^bottom <nb>) + (bottom-corner ^number 1 ^color <c1f> ^status active) + (bottom-corner ^number 1 ^color <c1r> ^status active) + (bottom-corner ^number 1 ^color <c1b> ^status active) + (bottom-corner ^number 1 ^face <n1f> ^status active) + (bottom-corner ^number 1 ^face <n1r> ^status active) + (bottom-corner ^number 1 ^face <nb> ^status active) + (face ^number <n2f> ^block 5 ^color <c2f>) + (face ^number <n2r> ^block 5 ^color <c2r>) + (face-relation ^front <n2f> ^right <n2r> ^bottom <nb>) + (bottom-corner ^number 2 ^color <c2f> ^status active) + (bottom-corner ^number 2 ^color <c2r> ^status active) + (bottom-corner ^number 2 ^color <c2b> ^status active) + (bottom-corner ^number 2 ^face <n2f> ^status active) + (bottom-corner ^number 2 ^face <n2r> ^status active) + (bottom-corner ^number 2 ^face <nb> ^status active) + (face ^number <n3f> ^block 5 ^color <c3f>) + (face ^number <n3r> ^block 5 ^color <c3r>) + (face-relation ^front <n3f> ^right <n3r> ^bottom <nb>) + (bottom-corner ^number 3 ^color <c3f> ^status active) + (bottom-corner ^number 3 ^color <c3r> ^status active) + (bottom-corner ^number 3 ^color <c3b> ^status active) + (bottom-corner ^number 3 ^face <n3f> ^status active) + (bottom-corner ^number 3 ^face <n3r> ^status active) + (bottom-corner ^number 3 ^face <nb> ^status active) + (face ^number <n4f> ^block 5 ^color <c4f>) + (face ^number <n4r> ^block 5 ^color <c4r>) + (face-relation ^front <n4f> ^right <n4r> ^bottom <nb>) + (bottom-corner ^number 4 ^color <c4f> ^status active) + (bottom-corner ^number 4 ^color <c4r> ^status active) + (bottom-corner ^number 4 ^color <c4b> ^status active) + (bottom-corner ^number 4 ^face <n4f> ^status active) + (bottom-corner ^number 4 ^face <n4r> ^status active) + (bottom-corner ^number 4 ^face <nb> ^status active) +--> + (make bottom-corner ^id <id> ^status done) + (modify 6 ^status used) + (modify 7 ^status used) + (modify 8 ^status used) + (modify 15 ^status used) + (modify 16 ^status used) + (modify 17 ^status used) + (modify 24 ^status used) + (modify 25 ^status used) + (modify 26 ^status used) + (modify 33 ^status used) + (modify 34 ^status used) + (modify 35 ^status used)) + +(p orient_bottom_corner*bc1 + (goal ^want orient ^object bottom-corner ^id <id> ^status active) + (face ^number 6 ^block 5 ^color <cb>) + (face ^number <nf> ^block 9 ^color <cb>) + (face ^number <nr> ^block 9 ^color <cb>) + (face ^number <np> ^block 9 ^color <cb>) + (cubie-order ^face-num <nf> ^direction dn ^adj-face-num 6 + ^block 7 ^adj-blk-num <abn>) + (face ^number 6 ^block <abn> ^color <cb>) + (face-relation ^front <nf> ^right <nr> ^posterior <np> + ^top 1 ^bottom 6) +--> + (make vodor ^right <nr> ^bottom 6 ^id <id> ^status active)) + +(p orient_bottom_corner*bc2 + (goal ^want orient ^object bottom-corner ^id <id> ^status active) + (face ^number 6 ^block 5 ^color <cb>) + (face ^number <nr> ^block 7 ^color <cb>) + (face ^number <np> ^block 7 ^color <cb>) + (face ^number <nl> ^block 7 ^color <cb>) + (cubie-order ^face-num <nl> ^direction dn ^adj-face-num 6 + ^block 9 ^adj-blk-num <abn>) + (face ^number 6 ^block <abn> ^color <cb>) + (face-relation ^front <nf> ^right <nr> ^left <nl> ^posterior <np> + ^top 1 ^bottom 6) +--> + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 180 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 180 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 90 ^id <id> ^seq 7 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 8 ^status active)) + +(p orient_bottom_corner*bc3 + (goal ^want orient ^object bottom-corner ^id <id> ^status active) + (face ^number 6 ^block 5 ^color <cb>) + (face ^number <nr> ^block 7 ^color <cb>) + (face ^number <np> ^block 7 ^color <cb>) + (face ^number <np> ^block 9 ^color <cb>) + (face ^number <nl> ^block 9 ^color <cb>) + (face-relation ^front <nf> ^right <nr> ^left <nl> ^posterior <np> + ^top 1 ^bottom 6) +--> + (make vodor ^right <nr> ^bottom 6 ^id <id> ^status active)) + +(p orient_bottom_corner*bc4 + (goal ^want orient ^object bottom-corner ^id <id> ^status active) + (face ^number 6 ^block 5 ^color <cb>) + (face ^number <nf> ^block 7 ^color <cb>) + (face ^number <np> ^block 9 ^color <cb>) + (face-relation ^front <nf> ^right <nr> ^posterior <np> + ^top 1 ^bottom 6) + (cubie-order ^face-num <nf> ^direction dn ^adj-face-num 6 + ^block 9 ^adj-blk-num <abn1>) + (face ^number 6 ^block <abn1> ^color <cb>) + (cubie-order ^face-num <np> ^direction dn ^adj-face-num 6 + ^block 7 ^adj-blk-num <abn2>) + (face ^number 6 ^block <abn2> ^color <cb>) +--> + (make vodor ^right <nr> ^bottom 6 ^id <id> ^status active)) + +(p orient_bottom_corner*bc5 + (goal ^want orient ^object bottom-corner ^id <id> ^status active) + (face ^number 6 ^block 5 ^color <cb>) + (face ^number <nf> ^block 7 ^color <cb>) + (face ^number <nf> ^block 9 ^color <cb>) + (face-relation ^front <nf> ^right <nr> ^posterior <np> + ^top 1 ^bottom 6) + (cubie-order ^face-num <np> ^direction dn ^adj-face-num 6 + ^block 7 ^adj-blk-num <abn1>) + (face ^number 6 ^block <abn1> ^color <cb>) + (cubie-order ^face-num <np> ^direction dn ^adj-face-num 6 + ^block 9 ^adj-blk-num <abn2>) + (face ^number 6 ^block <abn2> ^color <cb>) +--> + (make vodor ^right <nr> ^bottom 6 ^id <id> ^status active)) + +(p orient_bottom_corner*bc6 + (goal ^want orient ^object bottom-corner ^id <id> ^status active) + (face ^number 6 ^block 5 ^color <cb>) + (face ^number <nf> ^block 7 ^color <cb>) + (face ^number <nr> ^block 9 ^color <cb>) + (face-relation ^front <nf> ^right <nr> ^posterior <np> + ^top 1 ^bottom 6) + (cubie-order ^face-num <nf> ^direction dn ^adj-face-num 6 + ^block 9 ^adj-blk-num <abn1>) + (face ^number 6 ^block <abn1> ^color <cb>) + (cubie-order ^face-num <np> ^direction dn ^adj-face-num 6 + ^block 9 ^adj-blk-num <abn2>) + (face ^number 6 ^block <abn2> ^color <cb>) +--> + (make vodor ^right <nr> ^bottom 6 ^id <id> ^status active)) + +(p orient_bottom_corner*bc7 + (goal ^want orient ^object bottom-corner ^id <id> ^status active) + (face ^number 6 ^block 5 ^color <cb>) + (face ^number <nr> ^block 7 ^color <cb>) + (face ^number <nr> ^block 9 ^color <cb>) + (face ^number <nl> ^block 7 ^color <cb>) + (face ^number <nl> ^block 9 ^color <cb>) + (face-relation ^front <nf> ^right <nr> ^left <nl> ^posterior <np> + ^top 1 ^bottom 6) +--> + (make vodor ^right <nr> ^bottom 6 ^id <id> ^status active)) + +(p orient_bottom_corner*rotate_utility + (goal ^want orient ^object bottom-corner ^id <id> ^status active) + (vodor ^right <nr> ^bottom 6 ^id <id> ^status active) +--> + (modify 2 ^status used) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction neg + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 180 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 7 ^status active) + (make goal ^want rotate ^object face ^number 6 ^direction pos + ^value 180 ^id <id> ^seq 8 ^status active)) + +(p position_orient_bottom_edge*make_bottom_edges + (goal ^want << position orient >> ^object bottom-edge ^id <id> + ^status active) + -(bottom-edge ^id <id> ^status << active done >>) + -(goal ^want clean-up ^object bottom-edge ^id <id> ^status active) + (face ^number 2 ^block 8 ^color <c28>) + (cubie-order ^face-num 2 ^direction dn ^adj-face-num 6 + ^block 8 ^adj-blk-num <blk268>) + (face ^number 6 ^block <blk268> ^color <c268>) + (face ^number 3 ^block 8 ^color <c38>) + (cubie-order ^face-num 3 ^direction dn ^adj-face-num 6 + ^block 8 ^adj-blk-num <blk368>) + (face ^number 6 ^block <blk368> ^color <c368>) + (face ^number 4 ^block 8 ^color <c48>) + (cubie-order ^face-num 4 ^direction dn ^adj-face-num 6 + ^block 8 ^adj-blk-num <blk468>) + (face ^number 6 ^block <blk468> ^color <c468>) + (face ^number 5 ^block 8 ^color <c58>) + (cubie-order ^face-num 5 ^direction dn ^adj-face-num 6 + ^block 8 ^adj-blk-num <blk568>) + (face ^number 6 ^block <blk568> ^color <c568>) +--> + (make bottom-edge ^number 1 ^face 2 ^color <c28> + ^id <id> ^status active) + (make bottom-edge ^number 1 ^face 6 ^color <c268> + ^id <id> ^status active) + (make bottom-edge ^number 2 ^face 3 ^color <c38> + ^id <id> ^status active) + (make bottom-edge ^number 2 ^face 6 ^color <c368> + ^id <id> ^status active) + (make bottom-edge ^number 3 ^face 4 ^color <c48> + ^id <id> ^status active) + (make bottom-edge ^number 3 ^face 6 ^color <c468> + ^id <id> ^status active) + (make bottom-edge ^number 4 ^face 5 ^color <c58> + ^id <id> ^status active) + (make bottom-edge ^number 4 ^face 6 ^color <c568> + ^id <id> ^status active)) + +(p position_bottom_edge*find_no_match + (goal ^want position ^object bottom-edge ^id <id> ^status active) + -(goal ^want clean-up ^object bottom-edge ^id <id> ^status active) + -(goal ^want rotate ^object face ^number 6 ^id <id> ^status active) + (bottom-edge ^number 1 ^face 2 ^id <id> ^status active) +--> + (make goal ^want clean-up ^object bottom-edge ^id <id> ^status active) + (make vodor ^right 4 ^left 2 ^front 3 ^bottom 6 ^id <id> + ^status active)) + +(p position_bottom_edge*clean_up_bottom_edge + (goal ^want position ^object bottom-edge ^id <id> ^status active) + (goal ^want clean-up ^object bottom-edge ^id <id> ^status active) + -(goal ^want rotate ^object face ^id <id> ^status active) + (bottom-edge ^id <id> ^status active) +--> + (modify 3 ^status used)) + +(p position_bottom_edge*clean_up_bottom_edge*exit + (goal ^want position ^object bottom-edge ^id <id> ^status active) + (goal ^want clean-up ^object bottom-edge ^id <id> ^status active) + -(goal ^want rotate ^object face ^id <id> ^status active) + -(bottom-edge ^id <id> ^status active) +--> + (remove 2)) + +(p position_bottom_edge*find_one_match + (goal ^want position ^object bottom-edge ^id <id> ^status active) + -(goal ^want clean-up ^object bottom-edge ^id <id> ^status active) + -(goal ^want rotate ^object face ^number 6 ^id <id> ^status active) + -(bottom-edge ^id <id> ^status done) + (face ^number <nf> ^block 5 ^color <cf>) + (face ^number <nb> ^block 5 ^color <cb>) + (face-relation ^front <nf> ^right <nr> ^left <nl> ^bottom <nb>) + (bottom-edge ^number <n1> ^color <cf> ^status active) + (bottom-edge ^number <n1> ^color <cb> ^status active) + (bottom-edge ^number <n1> ^face <nf> ^status active) + (bottom-edge ^number <n1> ^face <nb> ^status active) +--> + (make vodor ^right <nr> ^left <nl> ^front <nf> ^bottom <nb> ^id <id> + ^status active) + (make goal ^want clean-up ^object bottom-edge ^id <id> ^status active)) + +(p position_bottom_edge*match_four + (goal ^want position ^object bottom-edge ^id <id> ^status active) + -(goal ^want clean-up ^object bottom-edge ^id <id> ^status active) + -(goal ^want rotate ^object face ^id <id> ^status active) + -(bottom-edge ^id <id> ^status done) + (face ^number <n1f> ^block 5 ^color <c1f>) + (face ^number <nb> ^block 5 ^color <cb>) + (face-relation ^front <n1f> ^bottom <nb>) + (bottom-edge ^number 1 ^color <c1f> ^status active) + (bottom-edge ^number 1 ^color <cb> ^status active) + (bottom-edge ^number 1 ^face <n1f> ^status active) + (bottom-edge ^number 1 ^face <nb> ^status active) + (face ^number <n2f> ^block 5 ^color <c2f>) + (face-relation ^front <n2f> ^bottom <nb>) + (bottom-edge ^number 2 ^color <c2f> ^status active) + (bottom-edge ^number 2 ^color <cb> ^status active) + (bottom-edge ^number 2 ^face <n2f> ^status active) + (bottom-edge ^number 2 ^face <nb> ^status active) + (face ^number <n3f> ^block 5 ^color <c3f>) + (face-relation ^front <n3f> ^bottom <nb>) + (bottom-edge ^number 3 ^color <c3f> ^status active) + (bottom-edge ^number 3 ^color <cb> ^status active) + (bottom-edge ^number 3 ^face <n3f> ^status active) + (bottom-edge ^number 3 ^face <nb> ^status active) + (face ^number <n4f> ^block 5 ^color <c4f>) + (face-relation ^front <n4f> ^bottom <nb>) + (bottom-edge ^number 4 ^color <c4f> ^status active) + (bottom-edge ^number 4 ^color <cb> ^status active) + (bottom-edge ^number 4 ^face <n4f> ^status active) + (bottom-edge ^number 4 ^face <nb> ^status active) +--> + (make bottom-edge ^id <id> ^status done) + (modify 5 ^status used) + (modify 6 ^status used) + (modify 11 ^status used) + (modify 12 ^status used) + (modify 17 ^status used) + (modify 18 ^status used) + (modify 23 ^status used) + (modify 24 ^status used)) + +(p orient_bottom_edge*be1 + (goal ^want orient ^object bottom-edge ^id <id> ^status active) + -(goal ^want clean-up ^object bottom-edge ^id <id> ^status active) + -(goal ^want rotate ^object face ^id <id> ^status active) + -(bottom-edge ^id <id> ^status done) + (face ^number {2 <nf>} ^block 5 ^color <cf>) + (face ^number <nb> ^block 5 ^color <cb>) + (face-relation ^front <nf> ^posterior <np> ^right <nr> ^left <nl> + ^bottom <nb>) + (bottom-edge ^number <n1> ^face <nf> ^color <cb> ^status active) + (bottom-edge ^number <n1> ^face <nb> ^color <cf> ^status active) + (face ^number <nr> ^block 5 ^color <cr>) + (bottom-edge ^number <n2> ^face <nr> ^color <cb> ^status active) + (bottom-edge ^number <n2> ^face <nb> ^color <cr> ^status active) + (face ^number <np> ^block 5 ^color <cp>) + (bottom-edge ^number <n3> ^face <np> ^color <cb> ^status active) + (bottom-edge ^number <n3> ^face <nb> ^color <cp> ^status active) + (face ^number <nl> ^block 5 ^color <cl>) + (bottom-edge ^number <n4> ^face <nl> ^color <cb> ^status active) + (bottom-edge ^number <n4> ^face <nb> ^color <cl> ^status active) +--> + (make bottom-edge ^id <id> ^status done) + (modify 5 ^status used) + (modify 6 ^status used) + (modify 8 ^status used) + (modify 9 ^status used) + (modify 11 ^status used) + (modify 12 ^status used) + (modify 14 ^status used) + (modify 15 ^status used) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 180 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <nb> ^direction pos + ^value 180 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 7 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 8 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 9 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 10 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 11 ^status active) + (make goal ^want rotate ^object face ^number <nb> ^direction pos + ^value 180 ^id <id> ^seq 12 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 13 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 14 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 180 ^id <id> ^seq 15 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 16 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 17 ^status active) + (make goal ^want rotate ^object face ^number <nb> ^direction neg + ^value 90 ^id <id> ^seq 18 ^status active)) + +(p orient_bottom_edge*be2 + (goal ^want orient ^object bottom-edge ^id <id> ^status active) + -(goal ^want clean-up ^object bottom-edge ^id <id> ^status active) + -(goal ^want rotate ^object face ^id <id> ^status active) + -(bottom-edge ^id <id> ^status done) + (face ^number <nf> ^block 5 ^color <cf>) + (face ^number <nb> ^block 5 ^color <cb>) + (face-relation ^front <nf> ^posterior <np> ^right <nr> ^left <nl> + ^bottom <nb>) + (bottom-edge ^number <n1> ^face <nf> ^color <cb> ^status active) + (bottom-edge ^number <n1> ^face <nb> ^color <cf> ^status active) + (face ^number <nr> ^block 5 ^color <cr>) + (bottom-edge ^number <n2> ^face <nr> ^color <cr> ^status active) + (bottom-edge ^number <n2> ^face <nb> ^color <cb> ^status active) + (face ^number <np> ^block 5 ^color <cp>) + (bottom-edge ^number <n3> ^face <np> ^color <cb> ^status active) + (bottom-edge ^number <n3> ^face <nb> ^color <cp> ^status active) + (face ^number <nl> ^block 5 ^color <cl>) + (bottom-edge ^number <n4> ^face <nl> ^color <cl> ^status active) + (bottom-edge ^number <n4> ^face <nb> ^color <cb> ^status active) +--> + (make bottom-edge ^id <id> ^status done) + (modify 5 ^status used) + (modify 6 ^status used) + (modify 8 ^status used) + (modify 9 ^status used) + (modify 11 ^status used) + (modify 12 ^status used) + (modify 14 ^status used) + (modify 15 ^status used) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <nb> ^direction pos + ^value 90 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 7 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 8 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 9 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 10 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 11 ^status active) + (make goal ^want rotate ^object face ^number <nb> ^direction pos + ^value 90 ^id <id> ^seq 12 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 13 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 14 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 180 ^id <id> ^seq 15 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 16 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 17 ^status active) + (make goal ^want rotate ^object face ^number <nb> ^direction pos + ^value 90 ^id <id> ^seq 18 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 19 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 20 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 21 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 22 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 23 ^status active) + (make goal ^want rotate ^object face ^number <nb> ^direction pos + ^value 90 ^id <id> ^seq 24 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 25 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 26 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 27 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 28 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 29 ^status active) + (make goal ^want rotate ^object face ^number <nb> ^direction pos + ^value 180 ^id <id> ^seq 30 ^status active)) + +(p orient_bottom_edge*be3 + (goal ^want orient ^object bottom-edge ^id <id> ^status active) + -(goal ^want clean-up ^object bottom-edge ^id <id> ^status active) + -(goal ^want rotate ^object face ^id <id> ^status active) + -(bottom-edge ^id <id> ^status done) + (face ^number <nf> ^block 5 ^color <cf>) + (face ^number <nb> ^block 5 ^color <cb>) + (face-relation ^front <nf> ^posterior <np> ^right <nr> ^left <nl> + ^bottom <nb>) + (bottom-edge ^number <n1> ^face <nf> ^color <cf> ^status active) + (bottom-edge ^number <n1> ^face <nb> ^color <cb> ^status active) + (face ^number <nr> ^block 5 ^color <cr>) + (bottom-edge ^number <n2> ^face <nr> ^color <cr> ^status active) + (bottom-edge ^number <n2> ^face <nb> ^color <cb> ^status active) + (face ^number <np> ^block 5 ^color <cp>) + (bottom-edge ^number <n3> ^face <np> ^color <cb> ^status active) + (bottom-edge ^number <n3> ^face <nb> ^color <cp> ^status active) + (face ^number <nl> ^block 5 ^color <cl>) + (bottom-edge ^number <n4> ^face <nl> ^color <cb> ^status active) + (bottom-edge ^number <n4> ^face <nb> ^color <cl> ^status active) + (goal ^id <oldid>) + -(goal ^id > <oldid>) +--> + (modify 1 ^status done) + (modify 1 ^want position ^object bottom-edge ^id (compute <oldid> + 1) + ^status active) + (make bottom-edge ^id <id> ^status done) + (modify 5 ^status used) + (modify 6 ^status used) + (modify 8 ^status used) + (modify 9 ^status used) + (modify 11 ^status used) + (modify 12 ^status used) + (modify 14 ^status used) + (modify 15 ^status used) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <nb> ^direction neg + ^value 90 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 7 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 8 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction neg + ^value 90 ^id <id> ^seq 9 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 10 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 11 ^status active) + (make goal ^want rotate ^object face ^number <nb> ^direction neg + ^value 90 ^id <id> ^seq 12 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 13 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 14 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 180 ^id <id> ^seq 15 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 16 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 17 ^status active)) + +(p orient_position_bottom_edge*rotate_utility + (goal ^want { << orient position >> <w> } ^object bottom-edge ^id <id> + ^status active) + (vodor ^right <nr> ^left <nl> ^front <nf> ^bottom <nb> ^id <id> + ^status active) +--> + (modify 2 ^status used) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 1 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 2 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 3 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 4 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 5 ^status active) + (make goal ^want rotate ^object face ^number <nb> ^direction pos + ^value 180 ^id <id> ^seq 6 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction neg + ^value 90 ^id <id> ^seq 7 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction pos + ^value 90 ^id <id> ^seq 8 ^status active) + (make goal ^want rotate ^object face ^number <nf> ^direction pos + ^value 90 ^id <id> ^seq 9 ^status active) + (make goal ^want rotate ^object face ^number <nl> ^direction pos + ^value 90 ^id <id> ^seq 10 ^status active) + (make goal ^want rotate ^object face ^number <nr> ^direction neg + ^value 90 ^id <id> ^seq 11 ^status active)) + + + + + + + + + + + diff --git a/contrib/ops/test1.ops b/contrib/ops/test1.ops new file mode 100644 index 000000000..a257cb2a2 --- /dev/null +++ b/contrib/ops/test1.ops @@ -0,0 +1,21 @@ +(literalize c1 a1 a2) +(literalize c2 a1 a2) +(literalize c3 a1 a2) + +(p p1 + (start) + --> + (make c1 ^a1 5 ^a2 foo) + (make c2 ^a1 foo ^a2 1 ) + (make c3 ^a1 5 ^a2 foo) + (make c1 ^a1 10 ^a2 foo)) + + + +(p p2 + (c1 ^a1 <x> ^a2 <y>) + (c2 ^a1 <y> ^a2 < <x>) + - (c3 ^a1 <x> ^a2 foo) + --> + (write -------- x: <x> all fine --------- (crlf))) + diff --git a/contrib/ops/test2.ops b/contrib/ops/test2.ops new file mode 100644 index 000000000..dba08b059 --- /dev/null +++ b/contrib/ops/test2.ops @@ -0,0 +1,74 @@ + +(literalize loop ; loop counter + count) +(literalize buf ; input buffer + input) +(literalize buffield ; holds an atom from the input + extracted value) + +(vector-attribute input) + +(literal extracted = 2 + value = 3) + +; Test acceptline + +(p p1 + (start) ; begin here + --> + (make loop ^count 1) + (make buffield ^extracted FALSE ^value nil) ) + + +(p p2 + (loop ^count 1) ; Get a new line of input + --> + (write (crlf) Enter a line of "input: ") + (make buf ^input (acceptline nothing read)) + (modify 1 ^count 2) ) + + + + +(p p3 + (loop ^count { <x> > 1 < 128 }) ; Extract a field + (buf ^input <> end-of-file) + (buffield ^extracted FALSE) + --> + (modify 3 ^extracted TRUE ^value (substr 2 <x> <x>)) ) + + + +(p p4 + (loop ^count <x>) ; Print non-nil field + (buffield ^extracted TRUE ^value { <v> <> nil }) + --> + (write (crlf) Field <x> is <v>) + (modify 1 ^count (compute (<x> + 1))) + (modify 2 ^extracted FALSE) ) + + + +(p p5 + (loop ^count <x>) ; Skip over nil field + (buffield ^extracted TRUE ^value nil) + --> + (modify 1 ^count (compute (<x> + 1))) + (modify 2 ^extracted FALSE) ) + + + +(p p6 + (loop ^count 128) ; Start over again + (buf) + --> + (modify 1 ^count 1) + (remove 2) ) + + + +(p p7 + (buf ^input end-of-file) ; Exit on EOF + --> + (write (crlf) End-of-file reached in input.) + (halt) ) diff --git a/contrib/ops/test3.ops b/contrib/ops/test3.ops new file mode 100644 index 000000000..539650eb9 --- /dev/null +++ b/contrib/ops/test3.ops @@ -0,0 +1,110 @@ + + +(literalize component) (literalize context) (literalize pcon) (literalize datum) +(literalize computation) (literalize setattr) (literalize template) (literalize interaction) +(literalize lineitem) (literalize local) (literalize discrlist) (literalize task) +(literalize arg) (literalize call) (literalize order) (literalize wip) +(literalize location) (literalize input) (literalize object) (literalize x) +(literalize status) (literalize place) (literalize time) (literalize port) +(literalize module) (literalize link) (literalize lists) (literalize outnode) +(literalize operator) (literalize current) (literalize attval) (literalize choice) +(literalize applied) (literalize stateop) (literalize exit) +(literalize component0) (literalize context0) (literalize pcon0) (literalize datum0) +(literalize computation0) (literalize setattr0) (literalize template0) (literalize interaction0) +(literalize lineitem0) (literalize local0) (literalize discrlist0) (literalize task0) +(literalize arg0) (literalize call0) (literalize order0) (literalize wip0) +(literalize location0) (literalize input0) (literalize object0) (literalize x0) +(literalize status0) (literalize place0) (literalize time0) (literalize port0) +(literalize module0) (literalize link0) (literalize lists0) (literalize outnode0) +(literalize operator0) (literalize current0) (literalize attval0) (literalize choice0) +(literalize applied0) (literalize stateop0) (literalize exit0) +(literalize tank) (literalize pipe) (literalize measurement) (literalize reading) +(literalize goal) (literalize material) + +(literalize primer + spacer + role + cnt + null) + +(literalize count + spacer + role + null + val + delta + null2) + + + +(p start + (start) + --> + (remove 1) + (make primer ^role exist ^cnt 1) + (make primer ^role exist ^cnt 2) + (make primer ^role exist ^cnt 3) + (make primer ^role exist ^cnt 4) + (make primer ^role exist ^cnt 5) + (make primer ^role exist ^cnt 6) + (make primer ^role exist ^cnt 7) + (make primer ^role exist ^cnt 8) + (make primer ^role exist ^cnt 9) + (make primer ^role exist ^cnt 10) + (make primer ^role exist ^cnt 11) + (make primer ^role exist ^cnt 12) + (make primer ^role exist ^cnt 13) + (make primer ^role exist ^cnt 14) + (make primer ^role exist ^cnt 15) + (make primer ^role exist ^cnt 16) + (make primer ^role exist ^cnt 17) + (make primer ^role exist ^cnt 18) + (make primer ^role exist ^cnt 19) + (make primer ^role exist ^cnt 20) + (make primer ^role exist ^cnt 21) + (make primer ^role exist ^cnt 22) + (make primer ^role exist ^cnt 23) + (make primer ^role exist ^cnt 24) + (make primer ^role exist ^cnt 25) + (make primer ^role exist ^cnt 26) + (make primer ^role exist ^cnt 27) + (make primer ^role exist ^cnt 28) + (make primer ^role exist ^cnt 29) + (make primer ^role exist ^cnt 30) + (make count ^role exist ^val 1 ^delta 7) + (make count ^role exist ^val 2 ^delta 7) + (make count ^role exist ^val 3 ^delta 7) + (make count ^role exist ^val 4 ^delta 7) + (make count ^role exist ^val 5 ^delta 7) + (make count ^role exist ^val 6 ^delta 7) + (make count ^role exist ^val 7 ^delta 7) + (make primer ^role driver ^cnt -1)) + + + +(p driver + (primer ^role driver ^null <x>) + (count ^null <x> ^val <val> ^delta <delta>) + - (count ^val < <val>) + --> + (modify 2 ^val (compute <val> + <delta>))) + + +(p driverCopy + (primer ^role driver ^null <x>) + (count ^null <x> ^val <val> ^delta <delta>) + - (count ^val < <val>) + --> + (modify 2 ^val (compute <val> + <delta>))) + + + +(p cs + (primer ^role exist ^cnt <= 2) + (primer ^role exist ^cnt <= 2) + (primer ^role exist ^cnt <= 2) + (primer ^role exist ^cnt <= 1) + (primer ^role exist ^cnt <= 1) + (primer ^role exist ^cnt <= 1) + --> + (halt)) diff --git a/contrib/ops/tourney.ops b/contrib/ops/tourney.ops new file mode 100644 index 000000000..edfef50c5 --- /dev/null +++ b/contrib/ops/tourney.ops @@ -0,0 +1,299 @@ + +(literalize player + number + nights-scheduled) + +(literalize foursome + night + group + north + south + east + west) + +(literalize context + name) + +(literalize scheduling + night) + +(literalize already-played + player1 + player2) + +(literalize candidate + group + chosen + south + east + west) + + +(p startup + (start) +--> + (make player ^number 1 ^nights-scheduled 0) + (make player ^number 2 ^nights-scheduled 0) + (make player ^number 3 ^nights-scheduled 0) + (make player ^number 4 ^nights-scheduled 0) + (make player ^number 5 ^nights-scheduled 0) + (make player ^number 6 ^nights-scheduled 0) + (make player ^number 7 ^nights-scheduled 0) + (make player ^number 8 ^nights-scheduled 0) + (make player ^number 9 ^nights-scheduled 0) + (make player ^number 10 ^nights-scheduled 0) + (make player ^number 11 ^nights-scheduled 0) + (make player ^number 12 ^nights-scheduled 0) + (make player ^number 13 ^nights-scheduled 0) + (make player ^number 14 ^nights-scheduled 0) + (make player ^number 15 ^nights-scheduled 0) + (make player ^number 16 ^nights-scheduled 0) + (make foursome ^night 1 ^group a ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 1 ^group b ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 1 ^group c ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 1 ^group d ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 2 ^group a ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 2 ^group b ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 2 ^group c ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 2 ^group d ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 3 ^group a ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 3 ^group b ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 3 ^group c ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 3 ^group d ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 4 ^group a ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 4 ^group b ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 4 ^group c ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 4 ^group d ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 5 ^group a ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 5 ^group b ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 5 ^group c ^north nil ^south nil ^east nil ^west nil) + (make foursome ^night 5 ^group d ^north nil ^south nil ^east nil ^west nil) + (make context ^name north) + (make scheduling ^night 1) + (write (tabto 32) |Tournament Schedule| (crlf) (crlf) + (tabto 15) |N S E W| + (tabto 42) |N S E W| + (tabto 68) |N S E W| (crlf) + (tabto 15) |= = = =| + (tabto 42) |= = = =| + (tabto 68) |= = = =| (crlf))) + +(p north-pick-one-1 + (context ^name north) + (scheduling ^night <n>) + { <THE-FOURSOME> (foursome ^night <n> ^north nil) } + { <THE-PLAYER> (player ^number <p> ^nights-scheduled < <n>) } + (foursome ^night <n> ^north { <p1> <> nil }) + (foursome ^night <n> ^north { <p2> <> <p1> <> nil }) + (foursome ^night <n> ^north { <p3> <> <p2> <> <p1> <> nil }) + (already-played ^player1 <p> ^player2 <p1>) + (already-played ^player1 <p> ^player2 <p2>) + (already-played ^player1 <p> ^player2 <p3>) +--> + (modify <THE-PLAYER> ^nights-scheduled <n>) + (modify <THE-FOURSOME> ^north <p>) ) + +(p north-pick-one-2 + (context ^name north) + (scheduling ^night <n>) + { <THE-FOURSOME> (foursome ^night <n> ^north nil) } + { <THE-PLAYER> (player ^number <p> ^nights-scheduled < <n>) } + (foursome ^night <n> ^north { <p1> <> nil }) + (foursome ^night <n> ^north { <p2> <> <p1> <> nil }) + (already-played ^player1 <p> ^player2 <p1>) + (already-played ^player1 <p> ^player2 <p2>) +--> + (modify <THE-PLAYER> ^nights-scheduled <n>) + (modify <THE-FOURSOME> ^north <p>) ) + +(p north-pick-one-3 + (context ^name north) + (scheduling ^night <n>) + { <THE-FOURSOME> (foursome ^night <n> ^north nil) } + { <THE-PLAYER> (player ^number <p> ^nights-scheduled < <n>) } + (foursome ^night <n> ^north { <p1> <> nil }) + (already-played ^player1 <p> ^player2 <p1>) +--> + (modify <THE-PLAYER> ^nights-scheduled <n>) + (modify <THE-FOURSOME> ^north <p>) ) + +(p north-pick-one-4 + (context ^name north) + (scheduling ^night <n>) + { <THE-FOURSOME> (foursome ^night <n> ^north nil) } + { <THE-PLAYER> (player ^number <p> ^nights-scheduled < <n>) } +--> + (modify <THE-PLAYER> ^nights-scheduled <n>) + (modify <THE-FOURSOME> ^north <p>) ) + +(p north-done + { <THE-CONTEXT> (context ^name north) } +--> + (modify <THE-CONTEXT> ^name make-candidates)) + +(p make-candidates-make-candidate + (context ^name make-candidates) + (scheduling ^night { <n> < 3 }) + (foursome ^night <n> ^group <g> ^north <yankee>) + (player ^number <redneck> ^nights-scheduled < <n>) + (player ^number { <oriental> < <redneck> } ^nights-scheduled < <n>) + (player ^number { <cowboy> < <oriental> } ^nights-scheduled < <n>) + - (already-played ^player1 <yankee> ^player2 <redneck>) + - (already-played ^player1 <yankee> ^player2 <oriental>) + - (already-played ^player1 <yankee> ^player2 <cowboy>) + - (already-played ^player1 <redneck> ^player2 <oriental>) + - (already-played ^player1 <redneck> ^player2 <cowboy>) + - (already-played ^player1 <oriental> ^player2 <cowboy>) + - (candidate ^group <g> ^chosen no ^south <redneck> ^east <oriental>) + - (candidate ^group <g> ^chosen no ^south <redneck> ^west <cowboy>) + - (candidate ^group <g> ^chosen no ^east <oriental> ^west <cowboy>) +--> + (make candidate ^group <g> ^chosen no + ^south <redneck> ^east <oriental> ^west <cowboy>)) + +(p make-candidates-make-candidate-late + (context ^name make-candidates) + (scheduling ^night { <n> > 2 }) + (foursome ^night <n> ^group <g> ^north <yankee>) + (player ^number <redneck> ^nights-scheduled < <n>) + (player ^number { <oriental> < <redneck> } ^nights-scheduled < <n>) + (player ^number { <cowboy> < <oriental> } ^nights-scheduled < <n>) + - (already-played ^player1 <yankee> ^player2 <redneck>) + - (already-played ^player1 <yankee> ^player2 <oriental>) + - (already-played ^player1 <yankee> ^player2 <cowboy>) + - (already-played ^player1 <redneck> ^player2 <oriental>) + - (already-played ^player1 <redneck> ^player2 <cowboy>) + - (already-played ^player1 <oriental> ^player2 <cowboy>) +--> + (make candidate ^group <g> ^chosen no + ^south <redneck> ^east <oriental> ^west <cowboy>)) + +(p make-candidates-done + { <THE-CONTEXT> (context ^name make-candidates) } +--> + (modify <THE-CONTEXT> ^name make-choice)) + +(p make-choice-doit + { <THE-CONTEXT> (context ^name make-choice) } + { <WINNER-A> (candidate ^group a ^chosen no + ^south <sa> + ^east <ea> + ^west <wa>) } + { <WINNER-B> (candidate ^group b ^chosen no + ^south { <sb> <> <sa> <> <ea> <> <wa> } + ^east { <eb> <> <sa> <> <ea> <> <wa> } + ^west { <wb> <> <sa> <> <ea> <> <wa> }) } + { <WINNER-C> (candidate ^group c ^chosen no + ^south { <sc> <> <sa> <> <ea> <> <wa> <> <sb> <> <eb> <> <wb> } + ^east { <ec> <> <sa> <> <ea> <> <wa> <> <sb> <> <eb> <> <wb> } + ^west { <wc> <> <sa> <> <ea> <> <wa> <> <sb> <> <eb> <> <wb> }) } + { <WINNER-D> (candidate ^group d ^chosen no + ^south { <sd> + <> <sa> <> <ea> <> <wa> + <> <sb> <> <eb> <> <wb> + <> <sc> <> <ec> <> <wc> } + ^east { <ed> + <> <sa> <> <ea> <> <wa> + <> <sb> <> <eb> <> <wb> + <> <sc> <> <ec> <> <wc> } + ^west { <wd> + <> <sa> <> <ea> <> <wa> + <> <sb> <> <eb> <> <wb> + <> <sc> <> <ec> <> <wc> }) } +--> + (modify <WINNER-A> ^chosen yes) + (modify <WINNER-B> ^chosen yes) + (modify <WINNER-C> ^chosen yes) + (modify <WINNER-D> ^chosen yes) + (modify <THE-CONTEXT> ^name remove-candidates)) + +(p remove-candidates-bye + (context ^name remove-candidates) + { <THE-CANDIDATE> (candidate ^chosen no) } +--> + (remove <THE-CANDIDATE>)) + +(p remove-candidates-done + { <THE-CONTEXT> (context ^name remove-candidates) } +--> + (modify <THE-CONTEXT> ^name apply-choice)) + +(p apply-choice-doit + (context ^name apply-choice) + (scheduling ^night <n>) + { <THE-FOURSOME> (foursome ^night <n> ^group <g> ^north <yankee>) } + { <THE-CHOICE> (candidate ^group <g> ^chosen yes + ^south <redneck> ^east <oriental> ^west <cowboy>) } +--> + (modify <THE-FOURSOME> ^south <redneck> ^east <oriental> ^west <cowboy>) + (remove <THE-CHOICE>) + (make already-played ^player1 <yankee> ^player2 <redneck>) + (make already-played ^player2 <yankee> ^player1 <redneck>) + (make already-played ^player1 <yankee> ^player2 <oriental>) + (make already-played ^player2 <yankee> ^player1 <oriental>) + (make already-played ^player1 <yankee> ^player2 <cowboy>) + (make already-played ^player2 <yankee> ^player1 <cowboy>) + (make already-played ^player1 <redneck> ^player2 <oriental>) + (make already-played ^player2 <redneck> ^player1 <oriental>) + (make already-played ^player1 <redneck> ^player2 <cowboy>) + (make already-played ^player2 <redneck> ^player1 <cowboy>) + (make already-played ^player1 <oriental> ^player2 <cowboy>) + (make already-played ^player2 <oriental> ^player1 <cowboy>)) + +(p apply-choice-done + { <THE-CONTEXT> (context ^name apply-choice) } +--> + (modify <THE-CONTEXT> ^name report)) + +(p report-night-schedule + { <THE-CONTEXT> (context ^name report) } + (scheduling ^night <n>) + (foursome ^night <n> ^group a ^north <an> ^south <as> ^east <ae> ^west <aw>) + (foursome ^night <n> ^group b ^north <bn> ^south <bs> ^east <be> ^west <bw>) + (foursome ^night <n> ^group c ^north <cn> ^south <cs> ^east <ce> ^west <cw>) + (foursome ^night <n> ^group d ^north <dn> ^south <ds> ^east <de> ^west <dw>) +--> + (modify <THE-CONTEXT> ^name next-night) + (bind <n2> (compute <n> + 5)) + (bind <n3> (compute <n> + 10)) + (write (crlf) (rjust 1) |#| (rjust 1) <n> (rjust 1) - (tabto 5) + |Group A-| (rjust 3) <an> (rjust 3) <as> (rjust 3) <ae> (rjust 3) <aw> + (tabto 27) (rjust 1) |#| (rjust 2) <n2> (rjust 1) - (tabto 32) + |Group A-| (rjust 3) <an> (rjust 3) <ae> (rjust 3) <as> (rjust 3) <aw> + (tabto 53) (rjust 1) |#| (rjust 2) <n3> (rjust 1) - (tabto 58) + |Group A-| (rjust 3) <an> (rjust 3) <aw> (rjust 3) <ae> (rjust 3) <as>) + (write (crlf) + (tabto 5) + |Group B-| (rjust 3) <bn> (rjust 3) <bs> (rjust 3) <be> (rjust 3) <bw> + (tabto 32) + |Group B-| (rjust 3) <bn> (rjust 3) <be> (rjust 3) <bs> (rjust 3) <bw> + (tabto 58) + |Group B-| (rjust 3) <bn> (rjust 3) <bw> (rjust 3) <be> (rjust 3) <bs>) + (write (crlf) + (tabto 5) + |Group C-| (rjust 3) <cn> (rjust 3) <cs> (rjust 3) <ce> (rjust 3) <cw> + (tabto 32) + |Group C-| (rjust 3) <cn> (rjust 3) <ce> (rjust 3) <cs> (rjust 3) <cw> + (tabto 58) + |Group C-| (rjust 3) <cn> (rjust 3) <cw> (rjust 3) <ce> (rjust 3) <cs>) + (write (crlf) + (tabto 5) + |Group D-| (rjust 3) <dn> (rjust 3) <ds> (rjust 3) <de> (rjust 3) <dw> + (tabto 32) + |Group D-| (rjust 3) <dn> (rjust 3) <de> (rjust 3) <ds> (rjust 3) <dw> + (tabto 58) + |Group D-| (rjust 3) <dn> (rjust 3) <dw> (rjust 3) <de> (rjust 3) <ds> + (crlf))) + +(p next-night-more + { <THE-CONTEXT> (context ^name next-night) } + { <THE-NIGHT> (scheduling ^night { <n> < 5 }) } +--> + (modify <THE-CONTEXT> ^name north) + (modify <THE-NIGHT> ^night (compute <n> + 1))) + +(p next-night-done + (context ^name next-night) +--> + (write (tabto 32) |End of Scheduling| (crlf) (crlf))) + diff --git a/contrib/ops/ttt.ops b/contrib/ops/ttt.ops new file mode 100644 index 000000000..defe3823d --- /dev/null +++ b/contrib/ops/ttt.ops @@ -0,0 +1,308 @@ +(strategy mea) +(watch 0) + + +(literalize task + actor) +(literalize position + row column value identity) +(literalize opposite + of is) +(literalize player + with-mark is) +(literalize move + status whose-turn input) +(vector-attribute input) + + + +(p start +; generate the wm-elements defining the "board" and find out whether +; the human wants his mark to be x or o + (ready) + --> + (make task ^actor referee) + (make position ^row 1 ^column 1 ^value | | ^identity top-left) + (make position ^row 1 ^column 2 ^value | | ^identity top-middle) + (make position ^row 1 ^column 3 ^value | | ^identity top-right) + (make position ^row 2 ^column 1 ^value | | ^identity middle-left) + (make position ^row 2 ^column 2 ^value | | ^identity center) + (make position ^row 2 ^column 3 ^value | | ^identity middle-right) + (make position ^row 3 ^column 1 ^value | | ^identity bottom-left) + (make position ^row 3 ^column 2 ^value | | ^identity bottom-middle) + (make position ^row 3 ^column 3 ^value | | ^identity bottom-right) + (make opposite ^of x ^is o) + (make opposite ^of o ^is x) + (write (crlf) Do you want to be x or "o? " ) + (make player ^with-mark (accept) ^is human) ) + +(make ready) + +(p pop + ; if there is nothing more to do in the most recently generated task, + ; delete the task + (task) + --> + (remove 1) ) + + +(p referee--display-the-board + ; after each move, display the board + (task ^actor referee) + (move ^status made ^whose-turn <mark>) + (opposite ^of <mark> ^is <opponent-mark>) + (position ^row 1 ^column 1 ^value <l1>) + (position ^row 1 ^column 2 ^value <m1>) + (position ^row 1 ^column 3 ^value <r1>) + (position ^row 2 ^column 1 ^value <l2>) + (position ^row 2 ^column 2 ^value <m2>) + (position ^row 2 ^column 3 ^value <r2>) + (position ^row 3 ^column 1 ^value <l3>) + (position ^row 3 ^column 2 ^value <m3>) + (position ^row 3 ^column 3 ^value <r3>) + --> + (modify 2 ^status unmade ^whose-turn <opponent-mark>) + (write (crlf) (crlf) (crlf) + (tabto 12) <l1> (tabto 15) "|" (tabto 18) <m1> + (tabto 21) "|" (tabto 24) <r1> + (tabto 10) ----------------- + (tabto 12) <l2> (tabto 15) "|" (tabto 18) <m2> + (tabto 21) "|" (tabto 24) <r2> + (tabto 10) ----------------- + (tabto 12) <l3> (tabto 15) "|" (tabto 18) <m3> + (tabto 21) "|" (tabto 24) <r3>) ) + +(p referee--prepare-for-first-move +; identify the mark of the computer and create the move wm-element that +; will drive the game + (task ^actor referee) + (player ^with-mark <mark> ^is human) + (opposite ^of <mark> ^is <other-mark>) + --> + (write (crlf) (crlf) When you are asked where you want your |mark,| + enter two |numbers.| + (crlf) The first number should be the row you |want,| the + second |number, the column.|) + (make player ^with-mark <other-mark> ^is computer) + (make move ^status unmade ^whose-turn x) ) + +(p referee--get-a-good-mark +; if the human says he wants to be something other than x or o, make +; him x + (task ^actor referee) + (player ^with-mark <mark> ^is human) + - (opposite ^of <mark>) + --> + (modify 2 ^with-mark x) + (write (crlf) (crlf) Try to remember that |you're x.|) ) + +(p referee--next-move +; if it's time for the next move to be made, generate the appropriate +; subtask + (task ^actor referee) + (move ^status unmade ^whose-turn <mark>) + (player ^with-mark <mark> ^is <who>) + --> + (make task ^actor <who>) ) + +(p referee--recognize-column-win +; if someone has filled a column, note that fact + (task ^actor referee) + (move ^status unmade ^whose-turn <mark>) + (opposite ^of <mark> ^is <other-mark>) + (player ^with-mark <other-mark>) + (position ^column <c> ^value <other-mark>) + - (position ^column <c> ^value <> <other-mark>) + --> + (remove 2) + (make player ^with-mark <other-mark> ^is winner) ) + +(p referee--recognize-row-win +; if someone has filled a row, note that fact + (task ^actor referee) + (move ^status unmade ^whose-turn <mark>) + (opposite ^of <mark> ^is <other-mark>) + (player ^with-mark <other-mark>) + (position ^row <r> ^value <other-mark>) + - (position ^row <r> ^value <> <other-mark>) + --> + (remove 2) + (make player ^with-mark <other-mark> ^is winner) ) + +(p referee--recognize-diagonal-win +; if someone has filled a diagonal, note that fact + (task ^actor referee) + (move ^status unmade ^whose-turn <mark>) + (opposite ^of <mark> ^is <other-mark>) + (player ^with-mark <other-mark>) + (position ^row 2 ^column 2 ^value <other-mark>) + (position ^row {<r> <> 2} ^column {<c> <> 2} + ^identity <id> ^value <other-mark>) + (position ^row <c> ^column <r> + ^identity <> <id> ^value <other-mark>) + --> + (remove 2) + (make player ^with-mark <other-mark> ^is winner) ) + +(p referee--human-wins +; if the human won, let him know + (task ^actor referee) + (player ^with-mark <other-mark> ^is winner) + (player ^with-mark <other-mark> ^is human) + --> + (write (crlf) (crlf) You |win.| (crlf) (crlf)) ) + +(p referee--computer-wins +; if the computer won, let the human know + (task ^actor referee) + (player ^with-mark <other-mark> ^is winner) + (player ^with-mark <other-mark> ^is computer) + --> + (write (crlf) (crlf) I |win.| (crlf) (crlf)) ) + +(p referee--draw +; if there are no empty spaces, the game is a draw + (task ^actor referee) + (move ^status unmade ^whose-turn <mark>) + (player ^with-mark <mark>) + - (position ^value | |) + --> + (write (crlf) (crlf) We |drew.| (crlf) (crlf)) + (remove 2) ) + +(p referee--cleanup +; if the game is over, delete all of the wm-elements + (task ^actor referee) + - (move) + (<> task) + --> + (remove 2) ) + + +(p human--ask-for-next-move + ; get the position (row and column) where the human wants his mark + (task ^actor human) + (move ^status unmade ^input nil) + --> + (write (crlf) (crlf) Where do you want your "mark? ") + (modify 2 ^input (acceptline)) ) + +(p human--accept-move + ; if the move is legal, accept it + ; the move wm-element is remade so that the value of ^input becomes + ; nil (there are 2 simpler but less educational ways of achieving + ; this same end) + (task ^actor human) + (move ^status unmade ^whose-turn <mark> + ^input {<row> >= 0 <= 3} {<column> >= 0 <= 3} nil) + (position ^row <row> ^column <column> ^value | |) + --> + (remove 2) + (make move (substr 2 2 input) ^status made ^input nil) + (modify 3 ^value <mark>) ) + +(p human--reject-attempt-to-overwrite + ; if the position specified is not empty, complain + ; the move condition element in this rule differs from the move + ; condition in the previous rule only so you can see two equivalent + ; ways of expressing the same condition + (task ^actor human) + (move ^status unmade + ^input <row> <column> nil ^input << 1 2 3 >> << 1 2 3 >>) + (position ^row <row> ^column <column> ^value {<mark> <> | |}) + --> + (write (crlf) (crlf) There is already an <mark> in <row> <column>) + (modify 2 ^input nil nil) ) + +(p human--reject-out-of-bounds-move + ; if the row or column specified is not within bounds or if more than + ; two numbers have been entered, complain + ; the move wm-element is remade so that the value of ^input becomes + ; nil (there is a simpler but less educational way of achieving this + ; same end) + (task ^actor human) + (move ^status unmade ^input <> nil) + --> + (write (crlf) (crlf) (substr 2 input inf) is not a legal |move.|) + (remove 2) + (make move (substr 2 2 input) ^input nil) ) + + +(p computer--select-move + ; select any empty position + (task ^actor computer) + (move ^status unmade ^whose-turn <mark>) + - (position ^row 2 ^column 2 ^value | |) + (position ^row <r> ^column <c> ^value | |) + --> + (modify 2 ^status made) + (modify 3 ^value <mark>) ) + +(p computer--select-center + ; select the center if it's available + (task ^actor computer) + (move ^status unmade ^whose-turn <mark>) + (position ^row 2 ^column 2 ^value | |) + --> + (modify 2 ^status made) + (modify 3 ^value <mark>) ) + +(p computer--block-column-win + ; if the human has two in a column, block + (task ^actor computer) + (move ^status unmade ^whose-turn <mark>) + (position ^row <r> ^column <c> + ^value {<other-mark> <> <mark> <> | |}) + (position ^column <c> ^value | |) + (position ^row <> <r> ^column <c> ^value <other-mark>) + --> + (modify 2 ^status made) + (modify 4 ^value <mark>) ) + +(p computer--block-row-win + ; if the human has two in a row, block + (task ^actor computer) + (move ^status unmade ^whose-turn <mark>) + (position ^row <r> ^column <c> + ^value {<other-mark> <> <mark> <> | |}) + (position ^row <r> ^value | |) + (position ^row <r> ^column <> <c> ^value <other-mark>) + --> + (modify 2 ^status made) + (modify 4 ^value <mark>) ) + +(p computer--block-diagonal-win + ; if the human has two on a diagonal, block + (task ^actor computer) + (move ^status unmade ^whose-turn <mark>) + (position ^row 2 ^column 2 + ^value {<other-mark> <> <mark> <> | |}) + (position ^row {<r> <> 2} ^column {<c> <> 2} ^value | |) + (position ^row <c> ^column <r> ^value <other-mark>) + --> + (modify 2 ^status made) + (modify 4 ^value <mark>) ) + +(p computer--possible-column + ; if the computer has one mark in an otherwise empty column, put + ; another mark in that column + (task ^actor computer) + (move ^status unmade ^whose-turn <mark>) + (position ^row <r> ^column <c> ^value <mark>) + - (position ^row <> <r> ^column <c> ^value <> | |) + (position ^row <> <r> ^column <c> ^value | |) + --> + (modify 2 ^status made) + (modify 4 ^value <mark>) ) + +(p computer--possible-row + ; if the computer has one mark in an otherwise empty row, put + ; another mark in that row + (task ^actor computer) + (move ^status unmade ^whose-turn <mark>) + (position ^row <r> ^column <c> ^value <mark>) + - (position ^row <r> ^column <> <c> ^value <> | |) + (position ^row <r> ^column <> <c> ^value | |) + --> + (modify 2 ^status made) + (modify 4 ^value <mark>) ) diff --git a/contrib/ops/weaver.ops b/contrib/ops/weaver.ops new file mode 100644 index 000000000..c1b8711d9 --- /dev/null +++ b/contrib/ops/weaver.ops @@ -0,0 +1,8850 @@ +(literalize unit unit-name file-name) + +(literalize pin net-name pin-name external-net-name external-pin-name pin-left-x pin-left-y fixed-pin pin-x pin-y pin-layer pin-layer-constraint pin-channel-side pin-is-attached) + +(literalize channel channel-bottom-left-x channel-bottom-left-y channel-top-right-x channel-top-right-y channel-width channel-length no-of-left-pins no-of-right-pins no-of-bottom-pins no-of-top-pins right-fixed left-fixed bottom-fixed top-fixed channel-type no-of-fixed-sides) + +(literalize net net-name parent-name net-no-of-pins net-left-x net-left-y net-right-x net-right-y no-of-left-pins no-of-right-pins no-of-top-pins no-of-bottom-pins net-is-routed left-most-pin-name right-most-pin-name bottom-most-pin-name top-most-pin-name fixed-net net-layer external-net-name no-of-inter max-no-of-via) + +(literalize layer-info layer-name layer-order layer-priority) + +(literalize context present previous saved) + +(literalize ff net-name pin-name grid-layer grid-x grid-y came-from can-chng-layer) + +(literalize next-net-to-be-routed net-name no-of-attached-pins criteria) + +(literalize to-be-routed net-name no-of-attached-pins) + +(literalize occupied x y m) + +(literalize constraint constraint-type constraint-relation channel-side constraint-reason net-name-1 net-name-2 pin-name-1 pin-name-2 seg-id-1 seg-id-2) + +(literalize congestion direction coordinate no-of-nets extra-nets como) + +(literalize intersection net-name direction min max) + +(literalize horizontal min max com compo commo layer status min-net max-net net-name pin-name) + +(literalize vertical min max com compo commo layer status min-net max-net net-name pin-name) + +(literalize horizontal-s net-name min max com id top-count bot-count sum difference absolute side) + +(literalize vertical-s net-name min max com id top-count bot-count sum difference absolute side) + +(literalize total net-name row-col coor level-pins total-pins cong min-xy max-xy last-pin last-xy nets) + +(literalize tree net-name orientation com min max count id) + +(vector-attribute nets) + +(p p327 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max>) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min { <hmin> <= <gx> } ^max { <hmax> >= <gx> > <min> } ^com 1 ^id <id>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <> <id>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x { >= <hmin> <= <hmax> } ^pin-channel-side bottom) + (constraint ^constraint-type vertical ^seg-id-1 <id>) + (total ^net-name <> <nn>) + - (total-verti <nn>) + --> + (remove <t>) +) + +(p p328 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max>) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min { <hmin> <= <gx> < <max> } ^max { <hmax> >= <gx> } ^com <lr> ^id <id>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <lr> ^id <> <id>) + (last-row <lr>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x { >= <hmin> <= <hmax> } ^pin-channel-side top) + (constraint ^constraint-type vertical ^seg-id-2 <id>) + (total ^net-name <> <nn>) + - (total-verti <nn>) + --> + (remove <t>) +) + +(p p329 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max>) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> } ^max { <vmax> >= <gy> > <min> } ^com 1 ^id <id>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <> <id>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-y { >= <vmin> <= <vmax> } ^pin-channel-side left) + (constraint ^constraint-type horizontal ^seg-id-1 <id>) + (total ^net-name <> <nn>) + - (total-verti <nn>) + --> + (remove <t>) +) + +(p p330 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max>) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> < <max> } ^max { <vmax> >= <gy> } ^com <lc> ^id <id>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <lc> ^id <> <id>) + (last-col <lc>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-y { >= <vmin> <= <vmax> } ^pin-channel-side right) + (constraint ^constraint-type horizontal ^seg-id-2 <id>) + (total ^net-name <> <nn>) + - (total-verti <nn>) + --> + (remove <t>) +) + +(p p331 + { <c> (context ^present modify-total) } + --> + (modify <c> ^present delete-total) +) + +(p p332 + { <c> (context ^present delete-total) } + - (total) + --> + (remove <c>) + (make context ^previous find-no-of-pins-on-a-row-col) +) + +(p p333 + { <c> (context ^present extend-total) } + (last-row <lr>) + --> + (make maximum-total 0 0 0 1 0 <lr> 0) + (make merge-direction left) + (modify <c> ^present merge) + (make eliminate-total) +) + +(p p334 + { <c> (context ^present delete-total) } + --> + (modify <c> ^present extend-total) +) + +(p p335 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min { <hmin> <= <gx> } ^max { <hmax> >= <gx> } ^com 1 ^id <id> ^absolute <a> ^sum <s>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <> <id>) + - (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <hmin> ^max-xy <hmax> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x { >= <hmin> <= <hmax> } ^pin-channel-side bottom) + --> + (make (substr <t> 1 inf) ^min-xy <hmin> ^max-xy <hmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <hmin> <hmax>) +) + +(p p336 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min { <hmin> <= <gx> } ^max { <hmax> >= <gx> } ^com <lr> ^id <id> ^absolute <a> ^sum <s>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <lr> ^id <> <id>) + - (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <hmin> ^max-xy <hmax> ^last-pin checked) + (last-row <lr>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x { >= <hmin> <= <hmax> } ^pin-channel-side top) + --> + (make (substr <t> 1 inf) ^min-xy <hmin> ^max-xy <hmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <hmin> <hmax>) +) + +(p p337 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> } ^max { <vmax> >= <gy> } ^com 1 ^id <id> ^absolute <a> ^sum <s>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <> <id>) + - (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <vmin> ^max-xy <vmax> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-y { >= <vmin> <= <vmax> } ^pin-channel-side left) + --> + (make (substr <t> 1 inf) ^min-xy <vmin> ^max-xy <vmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <vmin> <vmax>) +) + +(p p338 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> } ^max { <vmax> >= <gy> } ^com <lc> ^id <id> ^absolute <a> ^sum <s>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <lc> ^id <> <id>) + - (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <vmin> ^max-xy <vmax> ^last-pin checked) + (last-col <lc>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-y { >= <vmin> <= <vmax> } ^pin-channel-side right) + --> + (make (substr <t> 1 inf) ^min-xy <vmin> ^max-xy <vmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <vmin> <vmax>) +) + +(p p339 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min 1 ^max { <hmax> >= <gx> } ^com <com> ^id <id> ^absolute <a> ^sum <s>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <garb> ^id <> <id>) + - (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy 1 ^max-xy <hmax> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x 0 ^pin-y <com> ^pin-channel-side left) + --> + (make (substr <t> 1 inf) ^min-xy 1 ^max-xy <hmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> 1 <hmax>) +) + +(p p340 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y <y>) + (horizontal-s ^net-name <nn> ^min { <hmin> <= <gx> } ^max <lc> ^com <com> ^id <id> ^absolute <a> ^sum <s>) + - (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <garb> ^id <> <id>) + - (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <hmin> ^max-xy <lc> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-y <com> ^pin-channel-side right) + (last-col <lc>) + --> + (make (substr <t> 1 inf) ^min-xy <hmin> ^max-xy <lc> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <hmin> <lc>) +) + +(p p341 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min 1 ^max { <vmax> >= <gy> } ^com <com> ^id <id> ^absolute <a> ^sum <s>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <garb> ^id <> <id>) + - (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy 1 ^max-xy <vmax> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x <com> ^pin-channel-side bottom) + --> + (make (substr <t> 1 inf) ^min-xy 1 ^max-xy <vmax> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> 1 <vmax>) +) + +(p p342 + (context ^present modify-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (ff ^net-name <nn> ^pin-name <pn> ^grid-x <x> ^grid-y { <gy> >= <min> <= <max> }) + (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> } ^max <lr> ^com <com> ^id <id> ^absolute <a> ^sum <s>) + - (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <garb> ^id <> <id>) + - (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <vmin> ^max-xy <lr> ^last-pin checked) + (pin ^net-name <nn> ^pin-name <pn> ^pin-x <com> ^pin-channel-side top) + (last-row <lr>) + --> + (make (substr <t> 1 inf) ^min-xy <vmin> ^max-xy <lr> ^level-pins <a> ^total-pins <s> ^last-pin checked ^last-xy <id> ^nets <nn> <vmin> <lr>) +) + +(p p343 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (total ^net-name <nn> ^row-col <rc> ^coor <y> ^last-pin checked) + --> + (remove <t>) +) + +(p p344 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + --> + (remove <t>) +) + +(p p345 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + (net ^net-name <nn> ^net-no-of-pins 2) + --> + (modify <t> ^last-pin checked ^nets <nn> <min> <max>) +) + +(p p346 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <y> ^min-xy <min> ^max-xy <max> ^last-pin <> checked) } + - (total ^last-pin checked) + --> + (modify <t> ^last-pin checked ^nets <nn> <min> <max>) +) + +(p p347 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max>) } + (last-col <lc>) + (horizontal-s ^net-name { <nn1> <> <nn> } ^min 1 ^max { >= <min> <> <lc> } ^com <y> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x 0 ^pin-y <y>) + - (pin ^net-name <nn> ^pin-y <y> ^pin-channel-side right) + --> + (remove <t>) +) + +(p p348 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <tmin> ^max-xy <max>) } + (last-col <lc>) + (horizontal-s ^net-name { <nn1> <> <nn> } ^min 1 ^max { <maxs> <> <lc> } ^com <y> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x 0 ^pin-y <y>) + (vertical ^net-name <nn> ^min <= <y> ^max >= <y> ^com { <min> > 1 <= <maxs> }) + - (vertical ^net-name <nn> ^min <= <y> ^max >= <y> ^com < <min>) + { <h> (horizontal ^net-name <nn1> ^min 0 ^max { <hmax> < <min> } ^com <y> ^layer <lay>) } + { <ff> (ff ^net-name <nn1> ^grid-x <hmax> ^grid-y <y> ^grid-layer <lay> ^came-from west) } + { <h1> (horizontal ^net-name nil ^min <hmax> ^max > <hmax> ^com <y> ^layer <lay>) } + - (pin ^net-name <nn> ^pin-y <y>) + - (vertical ^status nil ^net-name { <> <nn1> <> nil } ^min <= <y> ^max >= <y> ^com <min> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn1> <> nil } ^min <= <min> ^max >= <min> ^com <y> ^layer <lay>) + --> + (remove <t>) + (modify <h> ^max <min>) + (modify <h1> ^min <min> ^min-net <nn1>) + (modify <ff> ^grid-x <min> ^can-chng-layer nil) +) + +(p p349 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max>) } + (last-col <lc>) + (horizontal-s ^net-name { <nn1> <> <nn> } ^min { <= <max> <> 1 } ^max <lc> ^com <y> ^id <=> 1) + (pin ^net-name <nn1> ^pin-y <y> ^pin-channel-side right) + - (pin ^net-name <nn> ^pin-y <y> ^pin-channel-side left) + --> + (remove <t>) +) + +(p p350 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <tmax>) } + (last-col <lc>) + (horizontal-s ^net-name { <nn1> <> <nn> } ^min { <mins> <> 1 } ^max <lc> ^com <y> ^id <=> 1) + (pin ^net-name <nn1> ^pin-y <y> ^pin-channel-side right) + (vertical ^net-name <nn> ^min <= <y> ^max >= <y> ^com { <max> >= <mins> < <lc> }) + - (vertical ^net-name <nn> ^min <= <y> ^max >= <y> ^com > <max>) + { <h> (horizontal ^net-name <nn1> ^min { <hmin> > <max> } ^max <garb> ^com <y> ^layer <lay>) } + { <ff> (ff ^net-name <nn1> ^grid-x <hmin> ^grid-y <y> ^grid-layer <lay> ^came-from east) } + { <h1> (horizontal ^net-name nil ^min < <max> ^max <hmin> ^com <y> ^layer <lay>) } + - (pin ^net-name <nn> ^pin-y <y>) + - (vertical ^status nil ^net-name { <> <nn1> <> nil } ^min <= <y> ^max >= <y> ^com <max> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn1> <> nil } ^min <= <max> ^max >= <max> ^com <y> ^layer <lay>) + --> + (remove <t>) + (modify <h> ^min <max>) + (modify <h1> ^max <max> ^max-net <nn1>) + (modify <ff> ^grid-x <max> ^can-chng-layer nil) +) + +(p p351 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max>) } + (last-row <lr>) + (vertical-s ^net-name { <nn1> <> <nn> } ^min 1 ^max { >= <min> <> <lr> } ^com <x> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x <x> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x <x> ^pin-channel-side top) + --> + (remove <t>) +) + +(p p352 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <tmin> ^max-xy <max>) } + (last-row <lr>) + (vertical-s ^net-name { <nn1> <> <nn> } ^min 1 ^max { <maxs> <> <lr> } ^com <x> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x <x> ^pin-channel-side bottom) + (horizontal ^net-name <nn> ^min <= <x> ^max <x> ^com { <min> > 1 <= <maxs> }) + - (horizontal ^net-name <nn> ^min <= <x> ^max <x> ^com < <min>) + { <v> (vertical ^net-name <nn1> ^min 0 ^max { <vmax> < <min> } ^com <x> ^layer <lay>) } + { <ff> (ff ^net-name <nn1> ^grid-x <x> ^grid-y <vmax> ^grid-layer <lay> ^came-from south) } + { <v1> (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <x> ^layer <lay>) } + - (pin ^net-name <nn> ^pin-x <x>) + - (vertical ^status nil ^net-name { <> <nn1> <> nil } ^min <= <min> ^max >= <min> ^com <x>) + - (horizontal ^status nil ^net-name { <> <nn1> <> nil } ^min <= <x> ^max >= <x> ^com <min>) + --> + (remove <t>) + (modify <v> ^max <min>) + (modify <v1> ^min <min> ^min-net <nn1>) + (modify <ff> ^grid-y <min> ^can-chng-layer nil) +) + +(p p353 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max>) } + (last-row <lr>) + (vertical-s ^net-name { <nn1> <> <nn> } ^min { <= <max> <> 1 } ^max <lr> ^com <x> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x <x> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x <x> ^pin-channel-side bottom) + --> + (remove <t>) +) + +(p p354 + (context ^present delete-total) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <tmax>) } + (last-row <lr>) + (vertical-s ^net-name { <nn1> <> <nn> } ^min { <mins> <> 1 } ^max <lr> ^com <x> ^id <=> 1) + (pin ^net-name <nn1> ^pin-x <x> ^pin-channel-side top) + (horizontal ^net-name <nn> ^min <= <x> ^max >= <x> ^com { <max> >= <mins> < <lr> }) + - (horizontal ^net-name <nn> ^min <= <x> ^max >= <x> ^com > <max>) + { <v> (vertical ^net-name <nn1> ^min { <vmin> > <max> } ^max <garb> ^com <x> ^layer <lay>) } + { <ff> (ff ^net-name <nn1> ^grid-x <x> ^grid-y <vmin> ^grid-layer <lay> ^came-from north) } + { <v1> (vertical ^net-name nil ^min < <vmin> ^max <vmin> ^com <x> ^layer <lay>) } + - (pin ^net-name <nn> ^pin-x <x>) + - (vertical ^status nil ^net-name { <> <nn1> <> nil } ^min <= <max> ^max >= <max> ^com <x>) + - (horizontal ^status nil ^net-name { <> <nn1> <> nil } ^min <= <x> ^max >= <x> ^com <max>) + --> + (remove <t>) + (modify <v> ^min <max>) + (modify <v1> ^max <max> ^max-net <nn1>) + (modify <ff> ^grid-y <max> ^can-chng-layer nil) +) + +(p p355 + (context ^present extend-total) + - (switch-box) + { <t> (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-xy <id>) } + (last-row > <y>) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <id>) + - (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com <y>) + - (horizontal ^net-name <nn> ^min <= <min> ^max >= <min> ^com <y>) + - (horizontal ^net-name <nn> ^min <= <max> ^max >= <max> ^com <y>) + - (horizontal ^net-name <nn> ^min >= <min> ^max <= <max> ^com <y>) + (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com > <y>) + - (ff ^net-name <nn> ^grid-x { >= <min> <= <max> } ^grid-y <y> ^pin-name >= 1000) + --> + (modify <t> ^coor (compute <y> + 1)) +) + +(p p356 + (context ^present extend-total) + - (switch-box) + { <t> (total ^net-name <nn> ^row-col row ^coor { <y> > 0 } ^min-xy <min> ^max-xy <max> ^last-xy <id>) } + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <lr> ^id <id>) + (last-row <lr>) + - (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com <y>) + - (horizontal ^net-name <nn> ^min <= <min> ^max >= <min> ^com <y>) + - (horizontal ^net-name <nn> ^min <= <max> ^max >= <max> ^com <y>) + - (horizontal ^net-name <nn> ^min >= <min> ^max <= <max> ^com <y>) + (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com < <y>) + - (ff ^net-name <nn> ^grid-x { >= <min> <= <max> } ^grid-y <y> ^pin-name >= 1000) + --> + (modify <t> ^coor (compute <y> - 1)) +) + +(p p357 + (context ^present extend-total) + - (switch-box) + { <t> (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-xy <id>) } + (last-col > <x>) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <id>) + - (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com <x>) + - (vertical ^net-name <nn> ^min <= <min> ^max >= <min> ^com <x>) + - (vertical ^net-name <nn> ^min <= <max> ^max >= <max> ^com <x>) + - (vertical ^net-name <nn> ^min >= <min> ^max <= <max> ^com <x>) + (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com > <x>) + - (ff ^net-name <nn> ^grid-x <x> ^grid-y { >= <min> <= <max> } ^pin-name >= 1000) + --> + (modify <t> ^coor (compute <x> + 1)) +) + +(p p358 + (context ^present extend-total) + - (switch-box) + { <t> (total ^net-name <nn> ^row-col col ^coor { <x> > 0 } ^min-xy <min> ^max-xy <max> ^last-xy <id>) } + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <lc> ^id <id>) + (last-col <lc>) + - (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com <x>) + - (vertical ^net-name <nn> ^min <= <min> ^max >= <min> ^com <x>) + - (vertical ^net-name <nn> ^min <= <max> ^max >= <max> ^com <x>) + - (vertical ^net-name <nn> ^min >= <min> ^max <= <max> ^com <x>) + (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com < <x>) + - (ff ^net-name <nn> ^grid-x <x> ^grid-y { >= <min> <= <max> } ^pin-name >= 1000) + --> + (modify <t> ^coor (compute <x> - 1)) +) + +(p p359 + (context ^present extend-total) + (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-xy <id>) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <id>) + (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com <y>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y { <gy> < <y> } ^grid-layer <lay> ^pin-name <pn>) } + { <v> (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { <vmax> >= <y> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <y> ^max >= <y> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <y> ^layer <lay>) + --> + (make vertical ^min <y> ^max <vmax> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn> ^max-net <mn>) + (modify <v> ^max <gy> ^max-net <nn>) + (make vertical ^min <gy> ^max <y> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^net-name <nn> ^pin-name <pn>) + (modify <ff> ^grid-y <y> ^came-from south ^can-chng-layer nil) +) + +(p p360 + (context ^present extend-total) + (total ^net-name <nn> ^row-col row ^coor <y> ^min-xy <min> ^max-xy <max> ^last-xy <id>) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <lr> ^id <id>) + (last-row <lr>) + (horizontal ^net-name nil ^min <= <min> ^max >= <max> ^com <y>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y { <gy> > <y> } ^grid-layer <lay> ^pin-name <pn>) } + { <v> (vertical ^net-name nil ^min { <vmin> <= <y> } ^max { <vmax> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <y> ^max >= <y> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <y> ^layer <lay>) + --> + (make vertical ^min <gy> ^max <vmax> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn> ^max-net <mn>) + (modify <v> ^max <y> ^max-net <nn>) + (make vertical ^min <y> ^max <gy> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^net-name <nn> ^pin-name <pn>) + (modify <ff> ^grid-y <y> ^came-from north ^can-chng-layer nil) +) + +(p p361 + (context ^present extend-total) + (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-xy <id>) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com 1 ^id <id>) + (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com <x>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx> < <x> } ^grid-y { <gy> >= <min> <= <max> } ^grid-layer <lay> ^pin-name <pn>) } + { <v> (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> >= <x> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <x> ^max >= <x> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <x> ^layer <lay>) + --> + (make horizontal ^min <x> ^max <hmax> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn> ^max-net <mn>) + (modify <v> ^max <gx> ^max-net <nn>) + (make horizontal ^min <gx> ^max <x> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^net-name <nn> ^pin-name <pn>) + (modify <ff> ^grid-x <x> ^came-from west ^can-chng-layer nil) +) + +(p p362 + (context ^present extend-total) + (total ^net-name <nn> ^row-col col ^coor <x> ^min-xy <min> ^max-xy <max> ^last-xy <id>) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <lc> ^id <id>) + (last-col <lc>) + (vertical ^net-name nil ^min <= <min> ^max >= <max> ^com <x>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx> > <x> } ^grid-y { <gy> >= <min> <= <max> } ^grid-layer <lay> ^pin-name <pn>) } + { <v> (horizontal ^net-name nil ^min { <hmin> <= <x> } ^max { <hmax> >= <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <x> ^max >= <x> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <x> ^layer <lay>) + --> + (make horizontal ^min <gx> ^max <hmax> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn> ^max-net <mn>) + (modify <v> ^max <x> ^max-net <nn>) + (make horizontal ^min <x> ^max <gx> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^net-name <nn> ^pin-name <pn>) + (modify <ff> ^grid-x <x> ^came-from east ^can-chng-layer nil) +) + +(p p490 + { <c> (context ^present separate) } + --> + (modify <c> ^present reconnect) +) + +(p p491 + { <c> (context ^present reconnect) } + --> + (modify <c> ^present form-verti) +) + +(p p492 + { <c> (context ^present form-verti) } + --> + (modify <c> ^present partial-route) +) + +(p p493 + { <c> (context ^present partial-route) } + --> + (modify <c> ^present extend-pins) +) + +(p p494 + { <c1> (context ^present extend-pins) } + --> + (modify <c1> ^present nil ^previous extend-pins) +) + +(p p495 + { <c1> (context ^previous extend-pins) } + --> + (make switch-box) + (make context ^present propagate-constraint) + (remove <c1>) +) + +(p p496 + { <c1> (context ^previous extend-pins) } + (channel ^no-of-left-pins 0 ^no-of-right-pins 0) + --> + (remove <c1>) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p497 + { <c1> (context ^previous extend-pins) } + (channel ^no-of-bottom-pins 0 ^no-of-top-pins 0) + --> + (remove <c1>) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p498 + (context ^previous propagate-constraint) + (net ^net-is-routed <> yes) + --> + (remove 1) + (make context ^present lshape1) +) + +(p p499 + (context ^present lshape1) + --> + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p500 + { <c> (context ^previous find-no-of-pins-on-a-row-col) } + - (total) + - (extend-ff-tried) + --> + (remove <c>) + (make context ^present lshape4) +) + +(p p501 + { <c> (context ^present lshape4) } + --> + (remove <c>) + (make extend-ff-tried) + (make context ^present extend-ff) +) + +(p p502 + { <c> (context ^present extend-ff) } + --> + (remove <c>) + (make context ^previous extend-ff) +) + +(p p503 + { <c> (context ^previous extend-ff) } + - (extended-ff) + --> + (remove <c>) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p504 + { <c> (context ^previous extend-ff) } + { <e> (extended-ff) } + { <ex> (extend-ff-tried) } + --> + (remove <c> <e> <ex>) + (make context ^present find-no-of-pins-on-a-row-col) + (make goal cleanup extended-ff) +) + +(p p505 + (context ^previous find-no-of-pins-on-a-row-col) + - (total) + (extend-ff-tried) + - (total-verti) + --> + (remove 1) + (make context ^present find-no-of-vcg-hcg) + (make goal cleanup counted-verti) +) + +(p p506 + (context ^previous find-no-of-pins-on-a-row-col) + - (total) + (total-verti) + - (verti-has-loop) + --> + (remove 1) + (make verti-has-loop) + (make context ^present choose-between-total-verti) +) + +(p p507 + (context ^previous find-no-of-pins-on-a-row-col) + - (total) + (total-verti) + (verti-has-loop) + --> + (make context ^present extend-h-v-s) + (make goal cleanup total-verti) + (make goal cleanup counted-verti) + (make goal cleanup extend-ff-tried) + (remove 1 3) +) + +(p p508 + (context ^present choose-between-total-verti) + - (total-verti ^4 > 0) + --> + (modify 1 ^present extend-h-v-s) + (make goal cleanup counted-verti) +) + +(p p509 + (context ^previous find-no-of-vcg-hcg) + - (total-verti) + --> + (remove 1) + (make context ^present extend-h-v-s) +) + +(p p510 + (context ^present loose-constraint) + --> + (make context ^present lshape2) + (remove 1) +) + +(p p511 + (context ^present lshape2) + --> + (modify 1 ^present lshape3) +) + +(p p512 + (context ^present lshape3) + --> + (remove 1) + (make context ^present random0) +) + +(p p513 + (context ^present random0) + --> + (remove 1) + (make context ^present random1) +) + +(p p514 + (context ^present remove-routed-net-segments) + - (net ^net-is-routed <> yes) + - (horizontal ^net-name <> nil ^status nil) + - (vertical ^net-name <> nil ^status nil) + --> + (write (crlf) | Finished with the routing.|) + (halt) +) + +(p p1 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^com <min>) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side top) + - (horizontal-s ^net-name <nn> ^min <= <px> ^max >= <px> ^id <> <id>) + (pin ^net-name <> <nn> ^pin-x <min> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x <px> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { < <px> > <min> }) + (pin ^net-name <nn> ^pin-x > <px> ^pin-channel-side top) + --> + (modify <h> ^min <px>) + (make horizontal-s ^net-name <nn> ^min <min> ^max <px> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p2 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^com <min>) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side bottom) + - (horizontal-s ^net-name <nn> ^min <= <px> ^max >= <px> ^id <> <id>) + (pin ^net-name <> <nn> ^pin-x <min> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x <px> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { < <px> > <min> }) + (pin ^net-name <nn> ^pin-x > <px> ^pin-channel-side bottom) + --> + (modify <h> ^min <px>) + (make horizontal-s ^net-name <nn> ^min <min> ^max <px> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p3 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^com <max>) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side top) + - (horizontal-s ^net-name <nn> ^min <= <px> ^max >= <px> ^id <> <id>) + (pin ^net-name <> <nn> ^pin-x <max> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x <px> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { < <max> > <px> }) + (pin ^net-name <nn> ^pin-x < <px> ^pin-channel-side top) + --> + (modify <h> ^max <px>) + (make horizontal-s ^net-name <nn> ^min <px> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p4 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^com <max>) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side bottom) + - (horizontal-s ^net-name <nn> ^min <= <px> ^max >= <px> ^id <> <id>) + (pin ^net-name <> <nn> ^pin-x <max> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x <px> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { < <max> > <px> }) + (pin ^net-name <nn> ^pin-x < <px> ^pin-channel-side bottom) + --> + (modify <h> ^max <px>) + (make horizontal-s ^net-name <nn> ^min <px> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p5 + (context ^present reconnect) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <min1> ^max <min> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side top) + - (pin ^pin-x <max> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <max> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^max <max>) +) + +(p p6 + (context ^present reconnect) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <max1> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side bottom) + - (pin ^pin-x <min> ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <min> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^min <min>) +) + +(p p7 + (context ^present reconnect) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <min1> ^max <min> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side top) + - (pin ^pin-x <max> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <max> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^max <max>) +) + +(p p8 + (context ^present reconnect) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <max1> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side bottom) + - (pin ^pin-x <min> ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <min> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^min <min>) +) + +(p p9 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> } ^max { <max1> <= <max> } ^com <> <com>) + { <v> (vertical-s ^net-name <nn> ^com { <com1> >= <min1> <= <max1> }) } + (pin ^net-name <> <nn> ^pin-x <com1>) + (congestion ^direction col ^coordinate { <px> >= <min1> <= <max1> }) + - (pin ^net-name <> <nn> ^pin-x <px>) + - (vertical-s ^com <px>) + --> + (modify <v> ^com <px>) +) + +(p p10 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> <= <max> } ^max { <max1> >= <max> } ^com <> <com>) + { <v> (vertical-s ^net-name <nn> ^com { <com1> >= <min1> <= <max> }) } + (pin ^net-name <> <nn> ^pin-x <com1>) + (congestion ^direction col ^coordinate { <px> >= <min1> <= <max> }) + - (pin ^net-name <> <nn> ^pin-x <px>) + - (vertical-s ^com <px>) + --> + (modify <v> ^com <px>) +) + +(p p11 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom> ^id <id>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> } ^max { <max1> <= <max> } ^com <> <hcom>) + - (vertical-s ^net-name <nn> ^com { >= <min1> <= <max1> }) + { <v> (vertical-s ^net-name <nn> ^com { <vcom> < <min1> }) } + - (horizontal-s ^net-name <nn> ^min <= <vcom> ^max >= <vcom> ^id <> <id>) + --> + (modify <v> ^com <min1>) +) + +(p p12 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom> ^id <id>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> } ^max { <max1> <= <max> } ^com <> <hcom>) + - (vertical-s ^net-name <nn> ^com { >= <min1> <= <max1> }) + { <v> (vertical-s ^net-name <nn> ^com { <vcom> > <max1> }) } + - (horizontal-s ^net-name <nn> ^min <= <vcom> ^max >= <vcom> ^id <> <id>) + --> + (modify <v> ^com <max1>) +) + +(p p13 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom> ^id <id>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> <= <max> } ^max { <max1> >= <max> } ^com <> <hcom>) + - (vertical-s ^net-name <nn> ^com { >= <min1> <= <max> }) + { <v> (vertical-s ^net-name <nn> ^com { <vcom> < <min1> }) } + - (horizontal-s ^net-name <nn> ^min <= <vcom> ^max >= <vcom> ^id <> <id>) + --> + (modify <v> ^com <min1>) +) + +(p p14 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom> ^id <id>) + (horizontal-s ^net-name <nn> ^min { <min1> >= <min> <= <max> } ^max { <max1> >= <max> } ^com <> <hcom>) + - (vertical-s ^net-name <nn> ^com { >= <min1> <= <max> }) + { <v> (vertical-s ^net-name <nn> ^com { <vcom> > <max> }) } + - (horizontal-s ^net-name <nn> ^min <= <vcom> ^max >= <vcom> ^id <> <id>) + --> + (modify <v> ^com <max>) +) + +(p p15 + (context ^present reconnect) + (horizontal-s ^net-name <nn> ^min <min1> ^max <max1> ^id <id1>) + { <h> (horizontal-s ^net-name <nn> ^min <max1> ^max <max2> ^com <com> ^id <id2>) } + (horizontal-s ^net-name <nn> ^min <max2> ^max <max3> ^id <id3>) + - (horizontal-s ^net-name <nn> ^id { <> <id1> <> <id2> <> <id3> }) + (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com <max1>) + (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com <max2>) + --> + (modify <h> ^min <min1> ^max <max3>) +) + +(p p16 + (context ^present reconnect) + (vertical-s ^net-name <nn> ^min <min1> ^max <max1> ^id <id1>) + { <h> (vertical-s ^net-name <nn> ^min <max1> ^max <max2> ^com <com> ^id <id2>) } + (vertical-s ^net-name <nn> ^min <max2> ^max <max3> ^id <id3>) + - (vertical-s ^net-name <nn> ^id { <> <id1> <> <id2> <> <id3> }) + (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com <max1>) + (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com <max2>) + --> + (modify <h> ^min <min1> ^max <max3>) +) + +(p p17 + (context ^present separate) + { <v> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (horizontal-s ^net-name <nn> ^min <hmin> ^max <com> ^com <max>) + (pin ^net-name <nn> ^pin-y { <py> > <min> < <max> } ^pin-channel-side right) + - (pin ^net-name <nn> ^pin-x > <com> ^pin-y { > <py> <= <max> }) + - (pin ^net-name <nn> ^pin-x <com> ^pin-channel-side top) + - (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <py> < <max> }) + - (horizontal-s ^net-name <nn> ^min <com> ^max <hmax> ^com <max>) + --> + (modify <v> ^max <py>) + (make vertical-s ^net-name <nn> ^min <py> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p18 + (context ^present separate) + { <v> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (horizontal-s ^net-name <nn> ^min <com> ^max <hmax> ^com <max>) + (pin ^net-name <nn> ^pin-y { <py> > <min> < <max> } ^pin-channel-side left) + - (pin ^net-name <nn> ^pin-x < <com> ^pin-y { > <py> <= <max> }) + - (pin ^net-name <nn> ^pin-x <com> ^pin-channel-side top) + - (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <py> < <max> }) + - (horizontal-s ^net-name <nn> ^min <hmin> ^max <com> ^com <max>) + --> + (modify <v> ^max <py>) + (make vertical-s ^net-name <nn> ^min <py> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p19 + (context ^present separate) + { <v> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (horizontal-s ^net-name <nn> ^min <hmin> ^max <com> ^com <min>) + (pin ^net-name <nn> ^pin-y { <py> > <min> < <max> } ^pin-channel-side right) + - (pin ^net-name <nn> ^pin-x > <com> ^pin-y { < <py> >= <min> }) + - (pin ^net-name <nn> ^pin-x <com> ^pin-channel-side bottom) + - (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <min> < <py> }) + - (horizontal-s ^net-name <nn> ^min <com> ^max <hmax> ^com <min>) + --> + (modify <v> ^min <py>) + (make vertical-s ^net-name <nn> ^min <min> ^max <py> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p20 + (context ^present separate) + { <v> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (horizontal-s ^net-name <nn> ^min <com> ^max <hmax> ^com <min>) + (pin ^net-name <nn> ^pin-y { <py> > <min> < <max> } ^pin-channel-side left) + - (pin ^net-name <nn> ^pin-x < <com> ^pin-y { < <py> >= <min> }) + - (pin ^net-name <nn> ^pin-x <com> ^pin-channel-side bottom) + - (horizontal-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <min> < <py> }) + - (horizontal-s ^net-name <nn> ^min <hmin> ^max <com> ^com <min>) + --> + (modify <v> ^min <py>) + (make vertical-s ^net-name <nn> ^min <min> ^max <py> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p21 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^min <vmin> ^max <com> ^com <min>) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { < <px> >= <min> } ^pin-y > <com>) + - (pin ^net-name <nn> ^pin-y <com> ^pin-channel-side left) + - (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <min> < <px> }) + - (vertical-s ^net-name <nn> ^min <com> ^max <vmax> ^com <min>) + --> + (modify <h> ^min <px>) + (make horizontal-s ^net-name <nn> ^min <min> ^max <px> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p22 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^min <com> ^max <vmax> ^com <min>) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { < <px> >= <min> } ^pin-y < <com>) + - (pin ^net-name <nn> ^pin-y <com> ^pin-channel-side left) + - (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <min> < <px> }) + - (vertical-s ^net-name <nn> ^min <vmin> ^max <com> ^com <min>) + --> + (modify <h> ^min <px>) + (make horizontal-s ^net-name <nn> ^min <min> ^max <px> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p23 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^min <vmin> ^max <com> ^com <max>) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side top) + - (pin ^net-name <nn> ^pin-x { > <px> <= <max> } ^pin-y > <com>) + - (pin ^net-name <nn> ^pin-y <com> ^pin-channel-side right) + - (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <px> < <max> }) + - (vertical-s ^net-name <nn> ^min <com> ^max <vmax> ^com <max>) + --> + (modify <h> ^max <px>) + (make horizontal-s ^net-name <nn> ^min <px> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p24 + (context ^present separate) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <com> ^id <id>) } + (vertical-s ^net-name <nn> ^min <com> ^max <vmax> ^com <max>) + (pin ^net-name <nn> ^pin-x { <px> > <min> < <max> } ^pin-channel-side bottom) + - (pin ^net-name <nn> ^pin-x { > <px> <= <max> } ^pin-y < <com>) + - (pin ^net-name <nn> ^pin-y <com> ^pin-channel-side right) + - (vertical-s ^net-name <nn> ^min <= <com> ^max >= <com> ^com { > <px> < <max> }) + - (vertical-s ^net-name <nn> ^min <vmin> ^max <com> ^com <max>) + --> + (modify <h> ^max <px>) + (make horizontal-s ^net-name <nn> ^min <px> ^max <max> ^com <com> ^id (compute <id> + 1000) ^top-count 1 ^bot-count 1 ^difference 0 ^absolute 0 ^sum 2) +) + +(p p604 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x { <vcom> >= <min> <= <max> } ^pin-channel-side top) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1>) + - (horizontal-s ^net-name <bnn> ^min <= <vcom> ^max >= <vcom> ^id <> <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side bottom) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type vertical) +) + +(p p605 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x { <vcom> >= <min> <= <max> } ^pin-channel-side bottom) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1>) + - (horizontal-s ^net-name <bnn> ^min <= <vcom> ^max >= <vcom> ^id <> <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side top) + - (constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn>) + --> + (make constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn> ^seg-id-1 <id1> ^seg-id-2 <id> ^constraint-type vertical) +) + +(p p606 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x { <vcom> >= <min> <= <max> } ^pin-channel-side top) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1> ^com 1) + (horizontal-s ^net-name <bnn> ^min <= <vcom> ^max >= <vcom> ^id <> <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side bottom) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type vertical) +) + +(p p607 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x { <vcom> >= <min> <= <max> } ^pin-channel-side bottom) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1> ^com <> 1) + (horizontal-s ^net-name <bnn> ^min <= <vcom> ^max >= <vcom> ^id <> <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side top) + - (constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn>) + --> + (make constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn> ^seg-id-1 <id1> ^seg-id-2 <id> ^constraint-type vertical) +) + +(p p608 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference <> 0) + (vertical-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <com> ^id <id1>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x <vcom> ^pin-channel-side top) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side bottom) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type vertical) +) + +(p p609 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference <> 0) + (vertical-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <com> ^id <id1>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x <vcom> ^pin-channel-side bottom) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side top) + - (constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn>) + --> + (make constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn> ^seg-id-1 <id1> ^seg-id-2 <id> ^constraint-type vertical) +) + +(p p610 + (context ^present form-verti) + (horizontal-s ^net-name <tnn> ^min <min> ^max <max> ^com 1 ^id <id>) + (vertical-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (horizontal-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <lr> ^id <id1>) + (last-row <lr>) + (vertical-s ^net-name <bnn> ^com <vcom>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-x <vcom> ^pin-channel-side top) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-x <vcom> ^pin-channel-side bottom) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type vertical) +) + +(p p611 + (context ^present form-verti) + (vertical-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-y { <vcom> >= <min> <= <max> } ^pin-channel-side right) + (vertical-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-y <vcom> ^pin-channel-side left) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type horizontal) +) + +(p p612 + (context ^present form-verti) + (vertical-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference 0) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-y { <vcom> >= <min> <= <max> } ^pin-channel-side left) + (vertical-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^id <id1>) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-y <vcom> ^pin-channel-side right) + - (constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn>) + --> + (make constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn> ^seg-id-1 <id1> ^seg-id-2 <id> ^constraint-type horizontal) +) + +(p p613 + (context ^present form-verti) + (vertical-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference <> 0) + (horizontal-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (vertical-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <com> ^id <id1>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-y <vcom> ^pin-channel-side right) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-y <vcom> ^pin-channel-side left) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type horizontal) +) + +(p p614 + (context ^present form-verti) + (vertical-s ^net-name <tnn> ^min <min> ^max <max> ^com <com> ^id <id> ^difference <> 0) + (horizontal-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (vertical-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <com> ^id <id1>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-y <vcom> ^pin-channel-side left) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-y <vcom> ^pin-channel-side right) + - (constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn>) + --> + (make constraint ^net-name-1 <bnn> ^net-name-2 <tnn> ^pin-name-1 <bpn> ^pin-name-2 <tpn> ^seg-id-1 <id1> ^seg-id-2 <id> ^constraint-type horizontal) +) + +(p p615 + (context ^present form-verti) + (vertical-s ^net-name <tnn> ^min <min> ^max <max> ^com 1 ^id <id>) + (horizontal-s ^net-name <tnn> ^com { <vcom> >= <min> <= <max> }) + (vertical-s ^net-name { <bnn> <> <tnn> } ^min <= <vcom> ^max >= <vcom> ^com <lc> ^id <id1>) + (last-col <lc>) + (horizontal-s ^net-name <bnn> ^com <vcom>) + (pin ^net-name <tnn> ^pin-name <tpn> ^pin-y <vcom> ^pin-channel-side right) + (pin ^net-name <bnn> ^pin-name <bpn> ^pin-y <vcom> ^pin-channel-side left) + - (constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + --> + (make constraint ^net-name-1 <tnn> ^net-name-2 <bnn> ^pin-name-1 <tpn> ^pin-name-2 <bpn> ^seg-id-1 <id> ^seg-id-2 <id1> ^constraint-type horizontal) +) + +(p p616 + (context ^present form-verti) + (constraint ^constraint-type vertical ^net-name-1 <tnn> ^net-name-2 <bnn> ^seg-id-1 <tid> ^seg-id-2 <bid>) + (constraint ^constraint-type vertical ^net-name-1 <nn1> ^net-name-2 <tnn> ^seg-id-1 <id1> ^seg-id-2 <tid2>) + - (vertical-cycle <tnn> <tid> <tid2>) + --> + (make vertical-cycle <tnn> <tid> <tid2>) +) + +(p p617 + (context ^present form-verti) + (constraint ^constraint-type horizontal ^net-name-1 <tnn> ^net-name-2 <bnn> ^seg-id-1 <tid> ^seg-id-2 <bid>) + (constraint ^constraint-type horizontal ^net-name-1 <nn1> ^net-name-2 <tnn> ^seg-id-1 <id1> ^seg-id-2 <tid2>) + - (horizontal-cycle <tnn> <tid> <tid2>) + --> + (make horizontal-cycle <tnn> <tid> <tid2>) +) + +(p p618 + (context ^present remove-cycle) + { <h> (horizontal-cycle <nn>) } + - (constraint ^constraint-type horizontal ^net-name-1 <nn>) + - (constraint ^constraint-type horizontal ^net-name-2 <nn>) + --> + (remove <h>) +) + +(p p619 + (context ^present remove-cycle) + { <h> (horizontal-cycle <nn>) } + - (constraint ^constraint-type horizontal ^net-name-2 <nn>) + --> + (remove <h>) +) + +(p p620 + (context ^present remove-cycle) + { <h> (horizontal-cycle <nn>) } + - (constraint ^constraint-type horizontal ^net-name-1 <nn>) + --> + (remove <h>) +) + +(p p621 + (context ^present remove-cycle) + { <h> (vertical-cycle <nn>) } + - (constraint ^constraint-type vertical ^net-name-1 <nn>) + - (constraint ^constraint-type vertical ^net-name-2 <nn>) + --> + (remove <h>) +) + +(p p622 + (context ^present remove-cycle) + { <h> (vertical-cycle <nn>) } + - (constraint ^constraint-type vertical ^net-name-2 <nn>) + --> + (remove <h>) +) + +(p p623 + (context ^present remove-cycle) + { <h> (vertical-cycle <nn>) } + - (constraint ^constraint-type vertical ^net-name-1 <nn>) + --> + (remove <h>) +) + +(p p624 + { <c> (context ^present remove-cycle) } + --> + (remove <c>) +) + +(p p625 + (context ^present remove-cycle) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <min1> ^max <min> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side top) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <max>) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <max> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^max <max>) +) + +(p p626 + (context ^present remove-cycle) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <max1> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side bottom) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <min>) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <min> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^min <min>) +) + +(p p627 + (context ^present remove-cycle) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <min1> ^max <min> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side bottom) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side top) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <max>) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <max> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^max <max>) +) + +(p p628 + (context ^present remove-cycle) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^id <id1>) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <max1> ^id <id2>) } + (pin ^net-name <nn> ^pin-x <max> ^pin-channel-side top) + (pin ^net-name <nn> ^pin-x <min> ^pin-channel-side bottom) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <min>) + - (pin ^net-name <nn> ^pin-x { < <max> > <min> }) + (last-row <lr>) + - (horizontal-s ^net-name <nn> ^id <id1> ^com { > 1 < <lr> }) + - (horizontal-s ^net-name <nn> ^id <id2> ^com { > 1 < <lr> }) + --> + (remove <h1>) + (make vertical-s ^net-name <nn> ^min 1 ^max <lr> ^com <min> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) + (modify <h2> ^min <min>) +) + +(p p629 + (context ^present remove-cycle) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^com 1) + (ff ^net-name <nn> ^grid-x { <gx> >= <hmin> <= <hmax> } ^grid-y <gy> ^came-from south) + - (ff ^net-name <nn> ^grid-x <> <gx> ^grid-y < <gy>) + - (vertical-s ^net-name <nn> ^min 1 ^max > <gy> ^com <gx>) + --> + (make vertical-s ^net-name <nn> ^min 1 ^max (compute <gy> + 1) ^com <gx> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) +) + +(p p630 + (context ^present remove-cycle) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^com 1) + (ff ^net-name <nn> ^grid-x { <gx> >= <hmin> <= <hmax> } ^grid-y <gy> ^came-from south) + - (ff ^net-name <nn> ^grid-x <> <gx> ^grid-y <= <gy>) + { <v> (vertical-s ^net-name <nn> ^min 1 ^max <= <gy> ^com <gx>) } + --> + (modify <v> ^max (compute <gy> + 1)) +) + +(p p631 + (context ^present remove-cycle) + (last-row <lr>) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^com <lr>) + (ff ^net-name <nn> ^grid-x { <gx> >= <hmin> <= <hmax> } ^grid-y <gy> ^came-from north) + - (ff ^net-name <nn> ^grid-x <> <gx> ^grid-y > <gy>) + - (vertical-s ^net-name <nn> ^min < <gy> ^max <lr> ^com <gx>) + --> + (make vertical-s ^net-name <nn> ^min (compute <gy> - 1) ^max <lr> ^com <gx> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) +) + +(p p632 + (context ^present remove-cycle) + (last-row <lr>) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^com <lr>) + (ff ^net-name <nn> ^grid-x { <gx> >= <hmin> <= <hmax> } ^grid-y <gy> ^came-from north) + - (ff ^net-name <nn> ^grid-x <> <gx> ^grid-y >= <gy>) + { <v> (vertical-s ^net-name <nn> ^min >= <gy> ^max <lr> ^com <gx>) } + --> + (modify <v> ^min (compute <gy> - 1)) +) + +(p p633 + (context ^present remove-cycle) + (vertical-s ^net-name <nn> ^min <vmin> ^max <vmax> ^com 1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy> >= <vmin> <= <vmax> } ^came-from west) + - (ff ^net-name <nn> ^grid-x < <gx> ^grid-y <> <gy>) + - (horizontal-s ^net-name <nn> ^min 1 ^max > <gx> ^com <gy>) + --> + (make horizontal-s ^net-name <nn> ^min 1 ^max (compute <gx> + 1) ^com <gy> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) +) + +(p p634 + (context ^present remove-cycle) + (vertical-s ^net-name <nn> ^min <vmin> ^max <vmax> ^com 1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy> >= <vmin> <= <vmax> } ^came-from west) + - (ff ^net-name <nn> ^grid-x <= <gx> ^grid-y <> <gy>) + { <h> (horizontal-s ^net-name <nn> ^min 1 ^max <= <gx> ^com <gy>) } + --> + (modify <h> ^max (compute <gx> + 1)) +) + +(p p635 + (context ^present remove-cycle) + (last-col <lc>) + (vertical-s ^net-name <nn> ^min <vmin> ^max <vmax> ^com <lc>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy> >= <vmin> <= <vmax> } ^came-from east) + - (ff ^net-name <nn> ^grid-x > <gx> ^grid-y <> <gy>) + - (horizontal-s ^net-name <nn> ^min < <gx> ^max <lc> ^com <gy>) + --> + (make horizontal-s ^net-name <nn> ^min (compute <gx> - 1) ^max <lc> ^com <gy> ^id (genatom) ^difference 0 ^absolute 0 ^sum 2) +) + +(p p636 + (context ^present remove-cycle) + (last-col <lc>) + (vertical-s ^net-name <nn> ^min <vmin> ^max <vmax> ^com <lc>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy> >= <vmin> <= <vmax> } ^came-from east) + - (ff ^net-name <nn> ^grid-x >= <gx> ^grid-y <> <gy>) + { <h> (horizontal-s ^net-name <nn> ^min >= <gx> ^max <lc> ^com <gy>) } + --> + (modify <h> ^min (compute <gx> - 1)) +) + +(p p637 + (context ^present remove-cycle) + (last-row <lr>) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^sum 2 ^difference 0) + { <v> (vertical-s ^net-name <nn> ^min 1 ^max { <lr> <> 2 } ^com { <vcom> >= <hmin> <= <hmax> }) } + (pin ^net-name <nn> ^pin-x <vcom> ^pin-channel-side top) + (ff ^net-name <> <nn> ^grid-x <vcom> ^came-from south) + --> + (modify <v> ^min (compute <lr> - 1)) +) + +(p p638 + (context ^present remove-cycle) + (last-row <lr>) + (horizontal-s ^net-name <nn> ^min <hmin> ^max <hmax> ^sum 2 ^difference 0) + { <v> (vertical-s ^net-name <nn> ^min 1 ^max { <lr> <> 2 } ^com { <vcom> >= <hmin> <= <hmax> }) } + (pin ^net-name <nn> ^pin-x <vcom> ^pin-channel-side bottom) + (ff ^net-name <> <nn> ^grid-x <vcom> ^came-from north) + --> + (modify <v> ^max 2) +) + +(p p639 + (context ^present remove-cycle) + (last-col <lc>) + (vertical-s ^net-name <nn> ^min <hmin> ^max <hmax> ^sum 2 ^difference 0) + { <v> (horizontal-s ^net-name <nn> ^min 1 ^max { <lc> <> 2 } ^com { <vcom> >= <hmin> <= <hmax> }) } + (pin ^net-name <nn> ^pin-x <vcom> ^pin-channel-side right) + (ff ^net-name <> <nn> ^grid-x <vcom> ^came-from west) + --> + (modify <v> ^min (compute <lc> - 1)) +) + +(p p640 + (context ^present remove-cycle) + (last-col <lc>) + (vertical-s ^net-name <nn> ^min <hmin> ^max <hmax> ^sum 2 ^difference 0) + { <v> (horizontal-s ^net-name <nn> ^min 1 ^max { <lc> <> 2 } ^com { <vcom> >= <hmin> <= <hmax> }) } + (pin ^net-name <nn> ^pin-x <vcom> ^pin-channel-side left) + (ff ^net-name <> <nn> ^grid-x <vcom> ^came-from east) + --> + (modify <v> ^max 2) +) + +(p p472 + (context ^present partial-route) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) } + { <vs> (vertical-s ^net-name <nn> ^min <gy1> ^max <gy> ^com <gx>) } + { <ff2> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1> ^came-from south) } + { <v> (vertical ^net-name nil ^min <gy1> ^max <gy> ^com <gx> ^layer <lay>) } + --> + (modify <v> ^net-name <nn> ^pin-name <pn>) + (remove <ff1> <ff2> <vs>) +) + +(p p473 + (context ^present partial-route) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from east) } + { <vs> (horizontal-s ^net-name <nn> ^min <gx1> ^max <gx> ^com <gy>) } + { <ff2> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn1> ^came-from west) } + { <v> (horizontal ^net-name nil ^min <gx1> ^max <gx> ^com <gy> ^layer <lay>) } + --> + (modify <v> ^net-name <nn> ^pin-name <pn>) + (remove <ff1> <ff2> <vs>) +) + +(p p474 + (context ^present partial-route) + { <v1> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <vcom>) } + { <h> (horizontal-s ^net-name <nn> ^min <vcom> ^max <hmax> ^com <min> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <vmin> ^max <min> ^com <hmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmin> ^came-from east) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <max> ^came-from north) + --> + (remove <v2>) + (modify <h> ^com <vmin>) + (modify <v1> ^min <vmin>) +) + +(p p475 + (context ^present partial-route) + { <h> (horizontal-s ^net-name <nn> ^min <vcom> ^max <hmax> ^com <min> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <vmin> ^max <min> ^com <hmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmin> ^came-from east) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <min> ^came-from north) + --> + (modify <v2> ^com <vcom>) + (modify <h> ^com <vmin>) +) + +(p p476 + (context ^present partial-route) + { <v1> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <vcom>) } + { <h> (horizontal-s ^net-name <nn> ^min <hmin> ^max <vcom> ^com <min> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <vmin> ^max <min> ^com <hmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmin> ^came-from west) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <max> ^came-from north) + --> + (remove <v2>) + (modify <h> ^com <vmin>) + (modify <v1> ^min <vmin>) +) + +(p p477 + (context ^present partial-route) + { <h> (horizontal-s ^net-name <nn> ^min <hmin> ^max <vcom> ^com <min> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <vmin> ^max <min> ^com <hmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmin> ^came-from west) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <min> ^came-from north) + --> + (modify <v2> ^com <vcom>) + (modify <h> ^com <vmin>) +) + +(p p478 + (context ^present partial-route) + { <v1> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <vcom>) } + { <h> (horizontal-s ^net-name <nn> ^min <vcom> ^max <hmax> ^com <max> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <max> ^max <vmax> ^com <hmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmax> ^came-from east) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <min> ^came-from south) + --> + (remove <v2>) + (modify <h> ^com <vmax>) + (modify <v1> ^max <vmax>) +) + +(p p479 + (context ^present partial-route) + { <h> (horizontal-s ^net-name <nn> ^min <vcom> ^max <hmax> ^com <max> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <max> ^max <vmax> ^com <hmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmax> ^came-from east) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <max> ^came-from south) + --> + (modify <v2> ^com <vcom>) + (modify <h> ^com <vmax>) +) + +(p p480 + (context ^present partial-route) + { <v1> (vertical-s ^net-name <nn> ^min <min> ^max <max> ^com <vcom>) } + { <h> (horizontal-s ^net-name <nn> ^min <hmin> ^max <vcom> ^com <max> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <max> ^max <vmax> ^com <hmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmax> ^came-from west) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <min> ^came-from south) + --> + (remove <v2>) + (modify <h> ^com <vmax>) + (modify <v1> ^max <vmax>) +) + +(p p481 + (context ^present partial-route) + { <h> (horizontal-s ^net-name <nn> ^min <hmin> ^max <vcom> ^com <max> ^top-count 1 ^bot-count 1) } + { <v2> (vertical-s ^net-name <nn> ^min <max> ^max <vmax> ^com <hmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmax> ^came-from west) + (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <max> ^came-from south) + --> + (modify <v2> ^com <vcom>) + (modify <h> ^com <vmax>) +) + +(p p482 + (context ^present partial-route) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom>) } + { <v> (vertical-s ^net-name <nn> ^min <hcom> ^max <vmax> ^com <min> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <hmin> ^max <min> ^com <vmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmax> ^came-from north) + (ff ^net-name <nn> ^grid-x <max> ^grid-y <hcom> ^came-from east) + --> + (remove <h2>) + (modify <v> ^com <hmin>) + (modify <h1> ^min <hmin>) +) + +(p p483 + (context ^present partial-route) + { <v> (vertical-s ^net-name <nn> ^min <hcom> ^max <vmax> ^com <min> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <hmin> ^max <min> ^com <vmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmax> ^came-from north) + (ff ^net-name <nn> ^grid-x <min> ^grid-y <hcom> ^came-from east) + --> + (modify <h2> ^com <hcom>) + (modify <v> ^com <hmin>) +) + +(p p484 + (context ^present partial-route) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom>) } + { <v> (vertical-s ^net-name <nn> ^min <hcom> ^max <vmax> ^com <max> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <hmax> ^com <vmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmax> ^came-from north) + (ff ^net-name <nn> ^grid-x <min> ^grid-y <hcom> ^came-from west) + --> + (remove <h2>) + (modify <v> ^com <hmax>) + (modify <h1> ^max <hmax>) +) + +(p p485 + (context ^present partial-route) + { <v> (vertical-s ^net-name <nn> ^min <hcom> ^max <vmax> ^com <max> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <hmax> ^com <vmax> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmax> ^came-from north) + (ff ^net-name <nn> ^grid-x <max> ^grid-y <hcom> ^came-from west) + --> + (modify <h2> ^com <hcom>) + (modify <v> ^com <hmax>) +) + +(p p486 + (context ^present partial-route) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom>) } + { <v> (vertical-s ^net-name <nn> ^min <vmin> ^max <hcom> ^com <min> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <hmin> ^max <min> ^com <vmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmin> ^came-from south) + (ff ^net-name <nn> ^grid-x <max> ^grid-y <hcom> ^came-from east) + --> + (remove <h2>) + (modify <v> ^com <hmin>) + (modify <h1> ^min <hmin>) +) + +(p p487 + (context ^present partial-route) + { <v> (vertical-s ^net-name <nn> ^min <vmin> ^max <hcom> ^com <min> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <hmin> ^max <min> ^com <vmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <vmin> ^came-from south) + (ff ^net-name <nn> ^grid-x <min> ^grid-y <hcom> ^came-from east) + --> + (modify <h2> ^com <hcom>) + (modify <v> ^com <hmin>) +) + +(p p488 + (context ^present partial-route) + { <h1> (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^com <hcom>) } + { <v> (vertical-s ^net-name <nn> ^min <vmin> ^max <hcom> ^com <max> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <hmax> ^com <vmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmin> ^came-from south) + (ff ^net-name <nn> ^grid-x <min> ^grid-y <hcom> ^came-from west) + --> + (remove <h2>) + (modify <v> ^com <hmax>) + (modify <h1> ^max <hmax>) +) + +(p p489 + (context ^present partial-route) + { <v> (vertical-s ^net-name <nn> ^min <vmin> ^max <hcom> ^com <max> ^top-count 1 ^bot-count 1) } + { <h2> (horizontal-s ^net-name <nn> ^min <max> ^max <hmax> ^com <vmin> ^top-count 1 ^bot-count 1) } + (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <vmin> ^came-from south) + (ff ^net-name <nn> ^grid-x <max> ^grid-y <hcom> ^came-from west) + --> + (modify <h2> ^com <hcom>) + (modify <v> ^com <hmax>) +) + +(p p186 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> < 0 }) + - (horizontal-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from south) } + - (ff ^net-name <nn> ^grid-x <garb1> ^grid-y < <gy1>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y <gy1>) + - (horizontal ^net-name nil ^min < <gx2> ^max > <gx1> ^com <gy1>) + - (horizontal ^net-name nil ^min <gx2> ^max > <gx1> ^com <gy1> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx2> ^max <gx1> ^com <gy1> ^max-net nil) + { <v> (vertical ^net-name nil ^max { <max> > <gy1> } ^min { < <max> <= <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> bottom) + - (vertical-cycle <nn>) + --> + (modify <v> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy1> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p187 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> < 0 }) + - (horizontal-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from south) } + - (ff ^net-name <nn> ^grid-x <garb1> ^grid-y < <gy1>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y <gy1>) + - (horizontal ^net-name nil ^min < <gx1> ^max > <gx2> ^com <gy1>) + - (horizontal ^net-name nil ^min <gx1> ^max > <gx2> ^com <gy1> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx1> ^max <gx2> ^com <gy1> ^max-net nil) + { <v> (vertical ^net-name nil ^max { <max> > <gy1> } ^min { < <max> <= <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> bottom) + - (vertical-cycle <nn>) + --> + (modify <v> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy1> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p188 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> < 0 }) + - (horizontal-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from south) } + (vertical-s ^net-name <nn> ^min <= <gy1> ^max > <gy1> ^com <gx1>) + - (ff ^net-name <nn> ^grid-x <> <gx1> ^grid-y <= <gy1>) + { <v> (vertical ^net-name nil ^max { <max> > <gy1> } ^min { < <max> <= <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy1>) + - (vertical-s ^net-name <> <nn> ^min <= <gy2> ^max >= <gy2> ^com <gx1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> bottom) + - (vertical-cycle <nn>) + --> + (make extended-ff <nn> bottom) + (modify <v> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy1> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p189 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> > 0 }) + - (horizontal-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from north) } + - (ff ^net-name <nn> ^grid-x <garb1> ^grid-y > <gy1>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y <gy1>) + - (horizontal ^net-name nil ^min < <gx2> ^max > <gx1> ^com <gy1>) + - (horizontal ^net-name nil ^min <gx2> ^max > <gx1> ^com <gy1> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx2> ^max <gx1> ^com <gy1> ^max-net nil) + { <v> (vertical ^net-name nil ^max { <max> >= <gy1> } ^min { < <max> < <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy1> ^como <gy2>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> top) + - (vertical-cycle <nn>) + --> + (modify <v> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy1> ^min <gy2> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p190 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> > 0 }) + - (horizontal-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from north) } + - (ff ^net-name <nn> ^grid-x <garb1> ^grid-y > <gy1>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y <gy1>) + - (horizontal ^net-name nil ^min < <gx1> ^max > <gx2> ^com <gy1>) + - (horizontal ^net-name nil ^min <gx1> ^max > <gx2> ^com <gy1> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx1> ^max <gx2> ^com <gy1> ^max-net nil) + { <v> (vertical ^net-name nil ^max { <max> >= <gy1> } ^min { < <max> < <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy1> ^como <gy2>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> top) + - (vertical-cycle <nn>) + --> + (modify <v> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy1> ^min <gy2> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p191 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^difference { <d> > 0 }) + - (horizontal-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from north) } + (vertical-s ^net-name <nn> ^min < <gy1> ^max >= <gy1> ^com <gx1>) + - (ff ^net-name <nn> ^grid-x <> <gx1> ^grid-y >= <gy1>) + { <v> (vertical ^net-name nil ^max { <max> >= <gy1> } ^min { < <max> < <gy1> } ^com <gx1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy1> ^como <gy2>) + - (vertical-s ^net-name <> <nn> ^min <= <gy2> ^max >= <gy2> ^com <gx1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx1> ^layer <lay1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx1> ^max >= <gx1> ^com <gy2> ^layer <lay1>) + - (extended-ff <nn> top) + - (vertical-cycle <nn>) + --> + (make extended-ff <nn> top) + (modify <v> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy1> ^min <gy2> ^layer <lay1> ^com <gx1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p192 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (horizontal-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <max> ^grid-y <gy> ^grid-layer <lay> ^came-from south ^pin-name <pn>) } + - (horizontal ^net-name nil ^min < <max> ^max >= <max> ^com <gy>) + { <v> (vertical ^net-name nil ^max { <vmax> > <gy> } ^min { < <vmax> <= <gy> } ^com <max> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <max> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <max> ^max >= <max> ^com <gy2> ^layer <lay>) + - (vertical-cycle <nn>) + (horizontal ^net-name nil ^min < <max> ^max >= <max> ^com > <gy>) + --> + (modify <v> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy> ^layer <lay> ^com <max> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p193 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (horizontal-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <min> ^grid-y <gy> ^grid-layer <lay> ^came-from south ^pin-name <pn>) } + - (horizontal ^net-name nil ^min <= <min> ^max > <min> ^com <gy>) + { <v> (vertical ^net-name nil ^max { <vmax> > <gy> } ^min { < <vmax> <= <gy> } ^com <min> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <min> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <min> ^max >= <min> ^com <gy2> ^layer <lay>) + - (vertical-cycle <nn>) + (horizontal ^net-name nil ^min <= <min> ^max > <min> ^com > <gy>) + --> + (modify <v> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy> ^layer <lay> ^com <min> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p194 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (horizontal-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <max> ^grid-y <gy> ^grid-layer <lay> ^came-from north ^pin-name <pn>) } + - (horizontal ^net-name nil ^min < <max> ^max >= <max> ^com <gy>) + { <v> (vertical ^net-name nil ^max { <vmax> >= <gy> } ^min { < <vmax> < <gy> } ^com <max> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy> ^como <gy2>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <max> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <max> ^max >= <max> ^com <gy2> ^layer <lay>) + - (vertical-cycle <nn>) + (horizontal ^net-name nil ^min < <max> ^max >= <max> ^com < <gy>) + --> + (modify <v> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <gy2> ^layer <lay> ^com <max> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p195 + (context ^present extend-ff) + (horizontal-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (horizontal-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <min> ^grid-y <gy> ^grid-layer <lay> ^came-from north ^pin-name <pn>) } + - (horizontal ^net-name nil ^min <= <min> ^max > <min> ^com <gy>) + { <v> (vertical ^net-name nil ^max { <vmax> >= <gy> } ^min { < <vmax> < <gy> } ^com <min> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction row ^coordinate <gy> ^como <gy2>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <min> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <min> ^max >= <min> ^com <gy2> ^layer <lay>) + - (vertical-cycle <nn>) + (horizontal ^net-name nil ^min <= <min> ^max > <min> ^com < <gy>) + --> + (modify <v> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <gy2> ^layer <lay> ^com <min> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) +) + +(p p196 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> < 0 }) + - (vertical-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from west) } + - (ff ^net-name <nn> ^grid-x < <gx1> ^grid-y <garb1>) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y { <gy2> < <gy1> }) + - (vertical ^net-name nil ^min < <gy2> ^max > <gy1> ^com <gx1>) + - (vertical ^net-name nil ^min <gy2> ^max > <gy1> ^com <gx1> ^min-net nil) + - (vertical ^net-name nil ^min < <gy2> ^max <gy1> ^com <gx1> ^max-net nil) + { <v> (horizontal ^net-name nil ^max { <max> > <gx1> } ^min { < <max> <= <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> left) + - (horizontal-cycle <nn>) + --> + (modify <v> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^max <gx2> ^min <gx1> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p197 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> < 0 }) + - (vertical-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from west) } + - (ff ^net-name <nn> ^grid-x < <gx1> ^grid-y <garb1>) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y { <gy2> > <gy1> }) + - (vertical ^net-name nil ^min < <gy1> ^max > <gy2> ^com <gx1>) + - (vertical ^net-name nil ^min <gy1> ^max > <gy2> ^com <gx1> ^min-net nil) + - (vertical ^net-name nil ^min < <gy1> ^max <gy2> ^com <gx1> ^max-net nil) + { <v> (horizontal ^net-name nil ^max { <max> > <gx1> } ^min { < <max> <= <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> left) + - (horizontal-cycle <nn>) + --> + (modify <v> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^max <gx2> ^min <gx1> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p198 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> < 0 }) + - (vertical-s ^difference < <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from west) } + (horizontal-s ^net-name <nn> ^min <= <gx1> ^max > <gx1> ^com <gy1>) + - (ff ^net-name <nn> ^grid-x <= <gx1> ^grid-y <> <gy1>) + { <v> (horizontal ^net-name nil ^max { <max> > <gx1> } ^min { < <max> <= <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx1>) + - (horizontal-s ^net-name <> <nn> ^min <= <gx2> ^max >= <gx2> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> left) + - (horizontal-cycle <nn>) + --> + (make extended-ff <nn> left) + (modify <v> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^max <gx2> ^min <gx1> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p199 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> > 0 }) + - (vertical-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from east) } + - (ff ^net-name <nn> ^grid-x > <gx1> ^grid-y <garb1>) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y { <gy2> < <gy1> }) + - (vertical ^net-name nil ^min < <gy2> ^max > <gy1> ^com <gx1>) + - (vertical ^net-name nil ^min <gy2> ^max > <gy1> ^com <gx1> ^min-net nil) + - (vertical ^net-name nil ^min < <gy2> ^max <gy1> ^com <gx1> ^max-net nil) + { <v> (horizontal ^net-name nil ^max { <max> >= <gx1> } ^min { < <max> < <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx1> ^como <gx2>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> right) + - (horizontal-cycle <nn>) + --> + (modify <v> ^max <gx2> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx1> ^min <gx2> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p200 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> > 0 }) + - (vertical-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from east) } + - (ff ^net-name <nn> ^grid-x > <gx1> ^grid-y <gy1>) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y { <gy2> > <gy1> }) + - (vertical ^net-name nil ^min < <gy1> ^max > <gy2> ^com <gx1>) + - (vertical ^net-name nil ^min <gy1> ^max > <gy2> ^com <gx1> ^min-net nil) + - (vertical ^net-name nil ^min < <gy1> ^max <gy2> ^com <gx1> ^max-net nil) + { <v> (horizontal ^net-name nil ^max { <max> >= <gx1> } ^min { < <max> < <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx1> ^como <gx2>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> right) + - (horizontal-cycle <nn>) + --> + (modify <v> ^max <gx2> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx1> ^min <gx2> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p201 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^difference { <d> > 0 }) + - (vertical-s ^difference > <d>) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn> ^came-from east) } + (horizontal-s ^net-name <nn> ^min < <gx1> ^max >= <gx1> ^com <gy1>) + - (ff ^net-name <nn> ^grid-x >= <gx1> ^grid-y <> <gy1>) + { <v> (horizontal ^net-name nil ^max { <max> >= <gx1> } ^min { < <max> < <gx1> } ^com <gy1> ^layer <lay1> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx1> ^como <gx2>) + - (horizontal-s ^net-name <> <nn> ^min <= <gx2> ^max >= <gx2> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy1> ^layer <lay1>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy1> ^max >= <gy1> ^com <gx2> ^layer <lay1>) + - (extended-ff <nn> right) + - (horizontal-cycle <nn>) + --> + (make extended-ff <nn> right) + (modify <v> ^max <gx2> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx1> ^min <gx2> ^layer <lay1> ^com <gy1> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p202 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (vertical-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <max> ^grid-layer <lay> ^came-from west ^pin-name <pn>) } + - (vertical ^net-name nil ^min < <max> ^max >= <max> ^com <gx>) + { <v> (horizontal ^net-name nil ^max { <vmax> > <gx> } ^min { < <vmax> <= <gx> } ^com <max> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <max> ^layer <lay>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <max> ^max >= <max> ^com <gx2> ^layer <lay>) + - (horizontal-cycle <nn>) + --> + (modify <v> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^max <gx2> ^min <gx> ^layer <lay> ^com <max> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p203 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (vertical-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <min> ^grid-layer <lay> ^came-from west ^pin-name <pn>) } + - (vertical ^net-name nil ^min <= <min> ^max > <min> ^com <gx>) + { <v> (horizontal ^net-name nil ^max { <vmax> > <gx> } ^min { < <vmax> <= <gx> } ^com <min> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <min> ^layer <lay>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <min> ^max >= <min> ^com <gx2> ^layer <lay>) + - (horizontal-cycle <nn>) + --> + (modify <v> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^max <gx2> ^min <gx> ^layer <lay> ^com <min> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p204 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (vertical-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <max> ^grid-layer <lay> ^came-from east ^pin-name <pn>) } + - (vertical ^net-name nil ^min < <max> ^max >= <max> ^com <gx>) + { <v> (horizontal ^net-name nil ^max { <vmax> >= <gx> } ^min { < <vmax> < <gx> } ^com <max> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx> ^como <gx2>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <max> ^layer <lay>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <max> ^max >= <max> ^com <gx2> ^layer <lay>) + - (horizontal-cycle <nn>) + --> + (modify <v> ^max <gx2> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx> ^min <gx2> ^layer <lay> ^com <max> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p205 + (context ^present extend-ff) + (vertical-s ^net-name <nn> ^min <min> ^max <max> ^difference 0) + - (vertical-s ^difference <> 0) + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <min> ^grid-layer <lay> ^came-from east ^pin-name <pn>) } + - (vertical ^net-name nil ^min <= <min> ^max > <min> ^com <gx>) + { <v> (horizontal ^net-name nil ^max { <vmax> >= <gx> } ^min { < <vmax> < <gx> } ^com <min> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (congestion ^direction col ^coordinate <gx> ^como <gx2>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <min> ^layer <lay>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <min> ^max >= <min> ^com <gx2> ^layer <lay>) + - (horizontal-cycle <nn>) + --> + (modify <v> ^max <gx2> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx> ^min <gx2> ^layer <lay> ^com <min> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) +) + +(p p206 + { <c> (context ^present extend-h-v-s) } + --> + (modify <c> ^present loose-constraint0) +) + +(p p207 + { <c> (context ^present extend-h-v-s) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^came-from west ^pin-name <pn>) } + (horizontal-s ^net-name <nn> ^min <= <gx> ^max { <hmaxs> > <gx> } ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^com <gy>) + (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy> ^com { <vcoms> > <gx> <= <hmaxs> }) + - (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy> ^com { >= <gx> < <vcoms> }) + { <h> (horizontal ^net-name nil ^min <gx> ^max { <hmax> >= <vcoms> } ^com <gy> ^layer <lay>) } + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <vcoms> ^layer <lay>) + --> + (make (substr <h> 1 inf) ^net-name <nn> ^pin-name <pn> ^max <vcoms>) + (modify <h> ^min <vcoms> ^min-net <nn>) + (modify <ff> ^grid-x <vcoms> ^can-chng-layer nil) + (modify <c> ^present propagate-constraint) +) + +(p p208 + { <c> (context ^present extend-h-v-s) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^came-from east ^pin-name <pn>) } + (horizontal-s ^net-name <nn> ^min { <hmins> < <gx> } ^max >= <gx> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^com <gy>) + (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy> ^com { <vcoms> < <gx> >= <hmins> }) + - (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy> ^com { <= <gx> > <vcoms> }) + { <h> (horizontal ^net-name nil ^min { <hmin> <= <vcoms> } ^max <gx> ^com <gy> ^layer <lay>) } + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <vcoms> ^layer <lay>) + --> + (make (substr <h> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <vcoms>) + (modify <h> ^max <vcoms> ^max-net <nn>) + (modify <ff> ^grid-x <vcoms> ^can-chng-layer nil) + (modify <c> ^present propagate-constraint) +) + +(p p209 + { <c> (context ^present extend-h-v-s) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^came-from south ^pin-name <pn>) } + (vertical-s ^net-name <nn> ^min <= <gy> ^max { <vmaxs> > <gy> } ^com <gx>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <gx>) + (horizontal-s ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { <hcoms> > <gy> <= <vmaxs> }) + - (horizontal-s ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { >= <gy> < <hcoms> }) + { <v> (vertical ^net-name nil ^min <gy> ^max { <vmax> >= <hcoms> } ^com <gx> ^layer <lay>) } + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <hcoms> ^layer <lay>) + --> + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^max <hcoms>) + (modify <v> ^min <hcoms> ^min-net <nn>) + (modify <ff> ^grid-y <hcoms> ^can-chng-layer nil) + (modify <c> ^present propagate-constraint) +) + +(p p210 + { <c> (context ^present extend-h-v-s) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^came-from north ^pin-name <pn>) } + (vertical-s ^net-name <nn> ^min { <vmins> < <gy> } ^max >= <gy> ^com <gx>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^com <gx>) + (horizontal-s ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { <hcoms> < <gy> >= <vmins> }) + - (horizontal-s ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { <= <gy> > <hcoms> }) + { <v> (vertical ^net-name nil ^min { <vmin> <= <hcoms> } ^max <gy> ^com <gx> ^layer <lay>) } + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <hcoms> ^layer <lay>) + --> + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <hcoms>) + (modify <v> ^max <hcoms> ^max-net <nn>) + (modify <ff> ^grid-y <hcoms> ^can-chng-layer nil) + (modify <c> ^present propagate-constraint) +) + +(p p29 + (goal cleanup <c>) + (<c>) + --> + (remove 2) +) + +(p p30 + (goal cleanup <c>) + - (<c>) + --> + (remove 1) +) + +(p p31 + (goal cleanup) + (verti-has-loop) + --> + (remove 2) +) + +(p p83 + (context ^present propagate-constraint) + --> + (remove 1) + (make context ^previous propagate-constraint) + (make context ^present remove-cycle) +) + +(p p84 + (context ^present << propagate-constraint extend-pins move-ff >>) + (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com> ^layer <lay> ^compo <cpo> ^commo <egarb1>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <min2> <= <max1> } ^max { <max2> >= <min1> } ^com <cpo> ^layer <lay> ^compo <garb1> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min { <min3> <= <com> } ^max { <max3> >= <cpo> > <min3> } ^com { <com2> <= <max1> >= <min1> <= <max2> >= <min2> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <mnn> ^max-net <man>) } + --> + (make vertical ^min <min3> ^max <com> ^com <com2> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^max-net <nn1> ^min-net <mnn>) + (make vertical ^min <cpo> ^max <max3> ^com <com2> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^min-net <nn2> ^max-net <man>) + (remove <v1>) +) + +(p p85 + (context ^present << propagate-constraint extend-pins >>) + (ff ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <com> ^layer <lay> ^compo <egarb2> ^commo <gy>) + { <v1> (vertical ^net-name nil ^min { <min3> <= <gy> } ^max { <max3> >= <com> > <min3> } ^com <gx> ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <mnn> ^max-net <man>) } + --> + (make vertical ^min <min3> ^max <gy> ^com <gx> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^max-net <nn1> ^min-net <mnn>) + (make vertical ^min <com> ^max <max3> ^com <gx> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^min-net <nn2> ^max-net <man>) + (remove <v1>) +) + +(p p86 + (context ^present << propagate-constraint extend-pins >>) + (ff ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <com> ^layer <lay> ^compo <gy> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min { <min3> <= <com> } ^max { <max3> >= <gy> > <min3> } ^com <gx> ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <mnn> ^max-net <man>) } + --> + (make vertical ^min <min3> ^max <com> ^com <gx> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^max-net <nn2> ^min-net <mnn>) + (make vertical ^min <gy> ^max <max3> ^com <gx> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^min-net <nn1> ^max-net <man>) + (remove <v1>) +) + +(p p87 + (context ^present propagate-constraint) + (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <garb1> ^max <max1> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min <min2> ^max <gar2> ^com <com> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <min2> > <max1> } ^com <com> ^layer <lay> ^compo <egarb5> ^commo <egarb6>) } + - (vertical ^com { > <max1> < <min2> }) + --> + (remove <h1>) +) + +(p p88 + (context ^present << propagate-constraint extend-pins move-ff >>) + (vertical ^status nil ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com> ^layer <lay> ^compo <cpo> ^commo <egarb1>) + (vertical ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <min2> <= <max1> } ^max { <max2> >= <min1> } ^com <cpo> ^layer <lay> ^compo <garb1> ^compo <egarb2>) + { <h1> (horizontal ^net-name nil ^min { <min3> <= <com> } ^max { <max3> >= <cpo> } ^com { <com2> <= <max1> >= <min1> <= <max2> >= <min2> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <mnn> ^max-net <man>) } + --> + (make horizontal ^min <min3> ^max <com> ^com <com2> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^min-net <mnn> ^max-net <nn1>) + (make horizontal ^min <cpo> ^max <max3> ^com <com2> ^compo <cpo2> ^commo <cmo2> ^layer <lay> ^max-net <man> ^min-net <nn2>) + (remove <h1>) +) + +(p p89 + (context ^present propagate-constraint) + (vertical ^status nil ^net-name { <nn1> <> nil } ^min <garb1> ^max <max1> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (vertical ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min <min2> ^max <garb2> ^com <com> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) + - (horizontal ^com { > <max1> < <min2> }) + { <v1> (vertical ^net-name nil ^min <max1> ^max { <min2> > <max1> } ^com <com> ^layer <lay> ^compo <egarb5> ^commo <egarb6>) } + --> + (remove <v1>) +) + +(p p90 + (context ^present propagate-constraint) + (vertical ^status nil ^net-name { <nn1> <> nil } ^min <vmin> ^max <garb1> ^com <vcom> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb2> <= <vcom> } ^max { <garb3> >= <vcom> } ^com <hcom> ^layer <lay> ^compo <vmin> ^commo <garb5>) + { <v1> (vertical ^net-name nil ^min <garb4> ^max { <vmin> > <garb4> } ^com <vcom> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) } + --> + (modify <v1> ^max <hcom> ^max-net <nn2>) +) + +(p p91 + (context ^present propagate-constraint) + (vertical ^status nil ^net-name { <nn1> <> nil } ^min <garb1> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (horizontal ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb2> <= <vcom> } ^max { <garb3> >= <vcom> } ^com <hcom> ^layer <lay> ^compo <garb4> ^commo <vmax>) + { <v1> (vertical ^net-name nil ^min <vmax> ^max { <garb5> > <vmax> } ^com <vcom> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) } + --> + (modify <v1> ^min <hcom> ^min-net <nn2>) +) + +(p p92 + (context ^present propagate-constraint) + (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <min> ^max <garb1> ^com <hcom> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (vertical ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb2> <= <hcom> } ^max { <garb3> >= <hcom> } ^com <vcom> ^layer <lay> ^compo <min> ^commo <egarb3>) + { <h1> (horizontal ^net-name nil ^min <garb4> ^max { <min> > <garb4> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + --> + (modify <h1> ^max <vcom> ^max-net <nn2>) +) + +(p p93 + (context ^present propagate-constraint) + (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <garb1> ^max <max> ^com <hcom> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (vertical ^status nil ^net-name { <nn2> <> <nn1> <> nil } ^min { <garb2> <= <hcom> } ^max { <garb3> >= <hcom> } ^com <vcom> ^layer <lay> ^compo <garb4> ^commo <max>) + { <h1> (horizontal ^net-name nil ^min <max> ^max { <garb4> > <max> } ^com <hcom> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) } + --> + (modify <h1> ^min <vcom> ^min-net <nn2>) +) + +(p p94 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + { <h1> (horizontal ^net-name nil ^min <garb3> ^max { <gx> > <garb3> } ^com <gy> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) } + (vertical ^status nil ^net-name { <nn2> <> <nn> <> nil } ^min { <garb1> <= <gy> } ^max { <garb2> >= <gy> } ^com <vcom> ^layer <lay> ^compo <gx> ^commo <egarb2>) + --> + (modify <h1> ^max <vcom> ^max-net <nn2>) +) + +(p p95 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { <garb4> > <gx> } ^com <gy> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + (vertical ^status nil ^net-name { <nn2> <> <nn> <> nil } ^min { <garb1> <= <gy> } ^max { <garb2> >= <gy> } ^com <vcom> ^layer <lay> ^compo <garb3> ^commo <gx>) + --> + (modify <h1> ^min <vcom> ^min-net <nn2>) +) + +(p p96 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + (horizontal ^status nil ^net-name { <nn2> <> <nn> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <hcom> ^layer <lay> ^compo <gy> ^commo <garb3>) + { <v1> (vertical ^net-name nil ^min <garb4> ^max { <gy> > <garb4> } ^com <gx> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + --> + (modify <v1> ^max <hcom> ^max-net <nn2>) +) + +(p p97 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + (horizontal ^status nil ^net-name { <nn2> <> <nn> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <hcom> ^layer <lay> ^compo <garb3> ^commo <gy>) + { <v1> (vertical ^net-name nil ^min <gy> ^max { <garb4> > <gy> } ^com <gx> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + --> + (modify <v1> ^min <hcom> ^min-net <nn2>) +) + +(p p98 + (context ^present << propagate-constraint extend-pins random1 check-for-routed-net >>) + { <h1> (horizontal ^min <min> ^max <= <min>) } + --> + (remove <h1>) +) + +(p p99 + (context ^present << propagate-constraint extend-pins random1 check-for-routed-net >>) + { <v1> (vertical ^min <min> ^max <= <min>) } + --> + (remove <v1>) +) + +(p p100 + { <h1> (horizontal ^min <min> ^max <= <min>) } + --> + (remove <h1>) +) + +(p p101 + { <v1> (vertical ^min <min> ^max <= <min>) } + --> + (remove <v1>) +) + +(p p102 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <min1> ^max { <max1> > <min1> } ^com <com1> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (vertical ^status nil ^min <= <com1> ^max >= <com1> ^com <min1>) + - (horizontal ^status nil ^min < <min1> ^max >= <min1> ^com <com1>) + (vertical ^status nil ^net-name <garb1> ^min { <vmin> <= <com1> } ^max { >= <com1> > <vmin> } ^com { <com2> > <min1> <= <max1> } ^layer <garb2> ^compo <egarb4> ^commo <egarb5>) + - (vertical ^status nil ^min <= <com1> ^max >= <com1> ^com { < <com2> >= <min1> }) + --> + (modify <h1> ^min <com2> ^min-net nil) +) + +(p p103 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <min1> ^max { <max1> > <min1> } ^com <com1> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (horizontal ^status nil ^min <= <com1> ^max >= <com1> ^com <min1>) + - (vertical ^status nil ^min < <min1> ^max >= <min1> ^com <com1>) + (horizontal ^status nil ^net-name <garb1> ^min { <hmin> <= <com1> } ^max { <garb2> >= <com1> > <hmin> } ^com { <com2> > <min1> <= <max1> } ^layer <garb3> ^compo <egarb4> ^commo <egarb5>) + - (horizontal ^status nil ^min <= <com1> ^max >= <com1> ^com { < <com2> >= <min1> }) + --> + (modify <v1> ^min <com2> ^min-net nil) +) + +(p p104 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <min1> ^max { <max1> > <min1> } ^com <com1> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + - (vertical ^status nil ^min <= <com1> ^max >= <com1> ^com <max1>) + - (horizontal ^status nil ^min <= <max1> ^max > <max1> ^com <com1>) + (vertical ^status nil ^net-name <garb1> ^min { <vmin> <= <com1> } ^max { <garb2> >= <com1> > <vmin> } ^com { <com2> >= <min1> < <max1> } ^layer <egarb1> ^compo <egarb2> ^commo <egarb3>) + - (vertical ^status nil ^min <= <com1> ^max >= <com1> ^com { > <com2> <= <max1> }) + --> + (modify <h1> ^max <com2> ^max-net nil) +) + +(p p105 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <min1> ^max { <max1> > <min1> } ^com <com1> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (horizontal ^status nil ^min <= <com1> ^max >= <com1> ^com <max1>) + - (vertical ^status nil ^min <= <max1> ^max > <max1> ^com <com1>) + (horizontal ^status nil ^net-name <garb1> ^min { <hmin> <= <com1> } ^max { <garb2> >= <com1> > <hmin> } ^com { <com2> >= <min1> < <max1> } ^layer <egarb1> ^compo <egarb4> ^commo <egarb5>) + - (horizontal ^status nil ^min <= <com1> ^max >= <com1> ^com { > <com2> <= <max1> }) + --> + (modify <v1> ^max <com2> ^max-net nil) +) + +(p p106 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <hmin> ^max { <hmax> > <hmin> } ^com <hcom> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) } + - (vertical ^com { > <hmin> < <hmax> }) + - (vertical ^status nil ^min <= <hcom> ^max >= <hcom> ^com <hmax> ^layer <lay>) + - (horizontal ^status nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <lay>) + (vertical ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <hmax> ^layer <> <lay> ^compo <egarb4> ^commo <egarb5>) + (vertical ^net-name { <> <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <hmin> ^layer <> <lay> ^compo <egarb2> ^commo <egarb3>) + --> + (remove <h1>) +) + +(p p107 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <vmin> ^max { <vmax> > <vmin> } ^com <vcom> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (horizontal ^com { > <vmin> < <vmax> }) + - (horizontal ^status nil ^min <= <vcom> ^max >= <vcom> ^com <vmax> ^layer <lay>) + - (vertical ^status nil ^min <vmax> ^max > <vmax> ^com <vcom> ^layer <lay>) + (horizontal ^net-name { <nn1> <> nil } ^min { <garb1> <= <vcom> } ^max { <garb2> >= <vcom> } ^com <vmax> ^layer { <garb3> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + (horizontal ^net-name { <> <nn1> <> nil } ^min { <garb4> <= <vcom> } ^max { <garb5> >= <vcom> } ^com <vmin> ^layer { <garb6> <> <lay> } ^compo <egarb4> ^commo <egarb5>) + --> + (remove <v1>) +) + +(p p108 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <hmin> ^max { <hmax> > <hmin> } ^com <hcom> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) } + - (vertical ^com { > <hmin> < <hmax> }) + - (vertical ^status nil ^min <= <hcom> ^max >= <hcom> ^com <hmin> ^layer <lay>) + - (horizontal ^status nil ^min < <hmin> ^max <hmin> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^min <= <hcom> ^max >= <hcom> ^com <hmax> ^layer <lay>) + - (horizontal ^status nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <lay>) + (vertical ^net-name { <nn1> <> nil } ^min { <garb1> <= <hcom> } ^max { <garb2> >= <hcom> } ^com <hmax> ^layer { <garb3> <> <lay> } ^compo <egarb2> ^commo <egarb3>) + (vertical ^net-name { <garb7> <> <nn1> <> nil } ^min { <gabr4> <= <hcom> } ^max { <garb5> >= <hcom> } ^com <hmin> ^layer { <garb6> <> <lay> } ^compo <egarb4> ^commo <egarb5>) + --> + (remove <h1>) +) + +(p p109 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <vmin> ^max { <vmax> > <vmin> } ^com <vcom> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) } + - (horizontal ^com { > <vmin> < <vmax> }) + - (horizontal ^status nil ^min <= <vcom> ^max >= <vcom> ^com <vmin> ^layer <lay>) + - (vertical ^status nil ^min < <vmin> ^max <vmin> ^com <vcom> ^layer <lay>) + (horizontal ^net-name { <nn1> <> nil } ^min { <garb1> <= <vcom> } ^max { <garb2> >= <vcom> } ^com <vmax> ^layer { <garb3> <> <lay> } ^compo <egarb2> ^commo <egarb3>) + (horizontal ^net-name { <garb7> <> <nn1> <> nil } ^min { <garb4> <= <vcom> } ^max { <garb5> >= <vcom> } ^com <vmin> ^layer { <garb6> <> <lay> } ^compo <egarb4> ^commo <egarb5>) + --> + (remove <v1>) +) + +(p p110 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <max2> > <max1> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + - (vertical ^min <= <hcom> ^max >= <hcom> ^com <max2> ^layer <lay>) + - (horizontal ^min <max2> ^max > <max2> ^com <hcom> ^layer <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com { > <max1> < <max2> }) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com { > <max1> < <max2> } ^max-net nil) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com { > <max1> < <max2> } ^min-net nil) + (horizontal ^net-name { <nn> <> nil } ^min <garb1> ^max <max1> ^com <hcom> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) + (vertical ^net-name { <nn1> <> <nn> <> nil } ^min { <garb4> <= <hcom> } ^max { <garb2> >= <hcom> } ^com <max2> ^layer { <garb3> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + - (vertical ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com { > <max1> < <max2> }) + --> + (modify <h1> ^max (compute <max2> - 1) ^max-net nil) +) + +(p p111 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <max2> > <max1> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + - (vertical ^min <= <hcom> ^max >= <hcom> ^com <max1> ^layer <lay>) + - (horizontal ^min < <max1> ^max <max1> ^com <hcom> ^layer <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com { > <max1> < <max2> }) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com { > <max1> < <max2> } ^max-net nil) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com { > <max1> < <max2> } ^min-net nil) + (horizontal ^net-name { <nn> <> nil } ^min <max2> ^max <garb1> ^com <hcom> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) + (vertical ^net-name { <nn1> <> <nn> <> nil } ^min { <garb4> <= <hcom> } ^max { <garb2> >= <hcom> } ^com <max1> ^layer { <garb3> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + - (vertical ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com { > <max1> < <max2> }) + --> + (modify <h1> ^min (compute <max1> + 1) ^min-net nil) +) + +(p p112 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <max2> > <max1> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + - (vertical ^min <= <hcom> ^max >= <hcom> ^com <max2> ^layer <lay>) + - (horizontal ^min <max2> ^max > <max2> ^com <hcom> ^layer <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com { >= <max1> < <max2> }) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com { >= <max1> < <max2> } ^max-net nil) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com { >= <max1> < <max2> } ^min-net nil) + - (horizontal ^min < <max1> ^max <max1> ^com <hcom> ^layer <lay>) + (vertical ^net-name { <nn1> <> nil } ^min { <garb1> <= <hcom> } ^max { <garb2> >= <hcom> } ^com <max2> ^layer { <garb3> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + - (vertical ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com { >= <max1> < <max2> }) + --> + (modify <h1> ^max (compute <max2> - 1) ^max-net nil) +) + +(p p113 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <max2> > <max1> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + - (vertical ^min <= <hcom> ^max >= <hcom> ^com <max1> ^layer <lay>) + - (horizontal ^min < <max1> ^max <max1> ^com <hcom> ^layer <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com { > <max1> <= <max2> }) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com { > <max1> <= <max2> } ^max-net nil) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com { > <max1> <= <max2> } ^min-net nil) + - (horizontal ^min <max2> ^max > <max2> ^com <hcom> ^layer <lay>) + (vertical ^net-name { <nn1> <> nil } ^min { <garb1> <= <hcom> } ^max { <garb2> >= <hcom> } ^com <max1> ^layer { <garb3> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + - (vertical ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com { > <max1> <= <max2> }) + --> + (modify <h1> ^min (compute <max1> + 1) ^min-net nil) +) + +(p p114 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <max1> ^max { <max2> > <max1> } ^com <hcom> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) } + (vertical ^net-name { <nn> <> nil } ^min <garb1> ^max <max1> ^com <hcom> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) + - (horizontal ^min <= <hcom> ^max >= <hcom> ^com <max2> ^layer <lay>) + - (vertical ^min <max2> ^max > <max2> ^com <hcom> ^layer <lay>) + - (horizontal ^net-name nil ^min < <hcom> ^max > <hcom> ^com { > <max1> < <max2> }) + - (horizontal ^net-name nil ^min < <hcom> ^max <hcom> ^com { > <max1> < <max2> } ^max-net nil) + - (horizontal ^net-name nil ^min <hcom> ^max > <hcom> ^com { > <max1> < <max2> } ^min-net nil) + (horizontal ^net-name { <nn1> <> <nn> <> nil } ^min { <garb2> <= <hcom> } ^max { <garb3> >= <hcom> } ^com <max2> ^layer { <garb4> <> <lay> } ^compo <egarb6> ^commo <egarb7>) + - (horizontal ^net-name { <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com { > <max1> < <max2> }) + --> + (modify <v1> ^max (compute <max2> - 1) ^max-net nil) +) + +(p p115 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^compo <gy>) + { <v1> (vertical ^net-name nil ^min <vmin> ^max { <gy> > <vmin> } ^com <gx> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { >= <vmin> < <gy> }) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { >= <vmin> < <gy> } ^max-net nil) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { >= <vmin> < <gy> } ^min-net nil) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <vmin> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <vmin> ^max >= <vmin> ^com <gx>) + --> + (modify <v1> ^max (compute <gy> - 1) ^max-net nil) +) + +(p p116 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { <max2> > <gx> } ^com <gy> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) } + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> <= <max2> } ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> <= <max2> }) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> <= <max2> } ^max-net nil) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> <= <max2> }) + --> + (modify <h1> ^min (compute <gx> + 1) ^min-net nil) +) + +(p p117 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <vmin> ^max { <vmax> > <vmin> } ^com <vcom> ^layer <lay> ^min-net { <nn> <> nil }) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { <hmax> >= <vcom> > <hmin> } ^com <vmax> ^layer <lay> ^commo <vmin> ^min-net { <> <nn> <> nil } ^max-net { <> <nn> <> nil }) + - (vertical ^net-name nil ^min < <vmax> ^max > <vmax> ^com { > <hmin> < <hmax> }) + - (vertical ^net-name nil ^min < <vmax> ^max <vmax> ^com { > <hmin> < <vcom> } ^max-net nil) + - (vertical ^net-name nil ^min < <vmax> ^max <vmax> ^com { > <vcom> < <hmax> } ^max-net nil) + - (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com { > <hmin> < <hmax> } ^min-net nil) + - (vertical ^net-name { <nn> <> nil } ^min <= <vmax> ^max >= <vmax> ^com { > <hmin> < <hmax> }) + --> + (remove <v1>) +) + +(p p118 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay1> ^compo <cpo1> ^commo <cmo1>) + - (vertical ^net-name nil ^com <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max > <com1> ^com > <max1>) + - (horizontal ^net-name nil ^min < <com1> ^max > <com1> ^com < <min1>) + { <h1> (horizontal ^net-name nil ^min { <min2> < <com1> } ^max { <max2> > <com1> > <min2> } ^com { <com2> >= <min1> <= <max1> } ^layer { <lay2> <> <lay1> } ^compo <cpo2> ^commo <cmo2>) } + - (horizontal ^net-name nil ^min < <com1> ^max > <com1> ^com { >= <min1> <= <max1> } ^layer <lay2>) + { <t1> (to-be-routed ^net-name { <nn2> <> <nn1> } ^no-of-attached-pins <nap>) } + - (horizontal ^status nil ^net-name { <nn2> <> nil } ^min <= <com1> ^max >= <com1>) + (pin ^net-name <nn2> ^pin-x < <com1>) + (pin ^net-name <nn2> ^pin-x > <com1>) + { <b1> (branch-no <pn>) } + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <b1>) + (make horizontal ^min <cmo1> ^max <cpo1> ^com <com2> ^layer <lay2> ^net-name <nn2> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make horizontal ^min <min2> ^max <cmo1> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (make horizontal ^min <cpo1> ^max <max2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <cmo1> ^grid-y <com2> ^grid-layer <lay2> ^came-from east) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <cpo1> ^grid-y <com2> ^grid-layer <lay2> ^came-from west) + (remove <h1>) +) + +(p p119 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay1> ^compo <cpo1> ^commo <cmo1>) + - (vertical ^net-name nil ^com <com1>) + { <h1> (horizontal ^net-name nil ^min { <min2> < <com1> } ^max { <max2> > <com1> > <min2> } ^com { <com2> >= <min1> <= <max1> } ^layer { <lay2> <> <lay1> } ^compo <cpo2> ^commo <cmo2>) } + - (horizontal ^net-name nil ^min < <com1> ^max > <com1> ^com > <com2>) + - (horizontal ^net-name nil ^min < <com1> ^max > <com1> ^com < <com2>) + { <t1> (to-be-routed ^net-name { <nn2> <> <nn1> } ^no-of-attached-pins <nap>) } + - (horizontal ^status nil ^net-name { <nn2> <> nil } ^min <= <com1> ^max >= <com1>) + (pin ^net-name <nn2> ^pin-x < <com1>) + (pin ^net-name <nn2> ^pin-x > <com1>) + { <b1> (branch-no <pn>) } + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <b1>) + (make horizontal ^min <cmo1> ^max <cpo1> ^com <com2> ^layer <lay2> ^net-name <nn2> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make horizontal ^min <min2> ^max <cmo1> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (make horizontal ^min <cpo1> ^max <max2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <cmo1> ^grid-y <com2> ^grid-layer <lay2> ^came-from east) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <cpo1> ^grid-y <com2> ^grid-layer <lay2> ^came-from west) + (remove <h1>) +) + +(p p120 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay1> ^compo <cpo1> ^commo <cmo1>) + - (horizontal ^net-name nil ^com <com1>) + - (vertical ^net-name nil ^min < <com1> ^max > <com1> ^com > <max1>) + - (vertical ^net-name nil ^min < <com1> ^max > <com1> ^com < <min1>) + { <v1> (vertical ^net-name nil ^min { <min2> < <com1> } ^max { <max2> > <com1> > <min2> } ^com { <com2> >= <min1> <= <max1> } ^layer { <lay2> <> <lay1> } ^compo <cpo2> ^commo <cmo2>) } + - (vertical ^net-name nil ^min < <com1> ^max > <com1> ^com { >= <min1> <= <max1> } ^layer <lay2>) + { <t1> (to-be-routed ^net-name { <nn2> <> <nn1> } ^no-of-attached-pins <nap>) } + - (vertical ^status nil ^net-name { <nn2> <> nil } ^min <= <com1> ^max >= <com1>) + (pin ^net-name <nn2> ^pin-y < <com1>) + (pin ^net-name <nn2> ^pin-y > <com1>) + { <b1> (branch-no <pn>) } + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <b1>) + (make vertical ^min <cmo1> ^max <cpo1> ^com <com2> ^layer <lay2> ^net-name <nn2> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make vertical ^min <min2> ^max <cmo1> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (make vertical ^min <cpo1> ^max <max2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com2> ^grid-y <cmo1> ^grid-layer <lay2> ^came-from north) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com2> ^grid-y <cpo1> ^grid-layer <lay2> ^came-from south) + (remove <v1>) +) + +(p p121 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay1> ^compo <cpo1> ^commo <cmo1>) + - (horizontal ^net-name nil ^com <com1>) + { <v1> (vertical ^net-name nil ^min { <min2> < <com1> } ^max { <max2> > <com1> > <min2> } ^com { <com2> >= <min1> <= <max1> } ^layer { <lay2> <> <lay1> } ^compo <cpo2> ^commo <cmo2>) } + - (vertical ^net-name nil ^min < <com1> ^max > <com1> ^com > <com2>) + - (vertical ^net-name nil ^min < <com1> ^max > <com1> ^com < <com2>) + { <t1> (to-be-routed ^net-name { <nn2> <> <nn1> } ^no-of-attached-pins <nap>) } + - (vertical ^status nil ^net-name { <nn2> <> nil } ^min <= <com1> ^max >= <com1>) + (pin ^net-name <nn2> ^pin-y < <com1>) + (pin ^net-name <nn2> ^pin-y > <com1>) + { <b1> (branch-no <pn>) } + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <b1>) + (make vertical ^min <cmo1> ^max <cpo1> ^com <com2> ^layer <lay2> ^net-name <nn2> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make vertical ^min <min2> ^max <cmo1> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (make vertical ^min <cpo1> ^max <max2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com2> ^grid-y <cmo1> ^grid-layer <lay2> ^came-from north) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com2> ^grid-y <cpo1> ^grid-layer <lay2> ^came-from south) + (remove <v1>) +) + +(p p122 + (context ^present propagate-constraint) + { <h1> (horizontal ^net-name nil ^min <min2> ^max { <max2> > <min2> } ^com <com2> ^layer <lay2> ^compo <cpo2> ^commo <cmo2>) } + - (horizontal ^net-name nil ^min <= <min2> ^max >= <max2> ^com > <com2>) + - (horizontal ^net-name nil ^min <= <min2> ^max >= <max2> ^com < <com2>) + - (horizontal ^net-name nil ^min <= <min2> ^max >= <max2> ^com <com2> ^layer <> <lay2>) + (congestion ^direction col ^coordinate { <x1> <= <max2> } ^como { <x2> >= <min2> }) + - (horizontal ^net-name nil ^min <= <x2> ^max >= <x1> ^com > <com2>) + - (horizontal ^net-name nil ^min <= <x2> ^max >= <x1> ^com < <com2>) + - (horizontal ^net-name nil ^min <= <x2> ^max >= <x1> ^com <com2> ^layer <> <lay2>) + { <t1> (to-be-routed ^net-name <nn2> ^no-of-attached-pins <nap>) } + - (horizontal ^status nil ^net-name { <nn2> <> nil } ^min <= <x2> ^max >= <x1>) + (pin ^net-name <nn2> ^pin-x <= <x2>) + (pin ^net-name <nn2> ^pin-x >= <x1>) + { <b1> (branch-no <pn>) } + - (horizontal ^net-name { <> <nn2> <> nil } ^min <= <x2> ^max >= <x2> ^com <com2> ^layer <lay2>) + - (vertical ^net-name { <> <nn2> <> nil } ^min <= <com2> ^max >= <com2> ^com <x2> ^layer <lay2>) + - (horizontal ^net-name { <> <nn2> <> nil } ^min <= <x1> ^max >= <x1> ^com <com2> ^layer <lay2>) + - (vertical ^net-name { <> <nn2> <> nil } ^min <= <com2> ^max >= <com2> ^com <x1> ^layer <lay2>) + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <b1>) + (make horizontal ^min <x2> ^max <x1> ^com <com2> ^layer <lay2> ^net-name <nn2> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make horizontal ^min <min2> ^max <x2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (make horizontal ^min <x1> ^max <max2> ^com <com2> ^layer <lay2> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <x2> ^grid-y <com2> ^grid-layer <lay2> ^came-from east) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <x1> ^grid-y <com2> ^grid-layer <lay2> ^came-from west) + (remove <h1>) +) + +(p p123 + (context ^present propagate-constraint) + { <v1> (vertical ^net-name nil ^min <min1> ^max { <max1> > <min1> } ^com { <com1> <> 1 } ^layer <lay1> ^compo <cpo1> ^commo <cmo1> ^min-net <mnn> ^max-net <xnn>) } + - (horizontal ^net-name nil ^min < <com1> ^max > <com1>) + (horizontal ^net-name nil ^min <com1> ^max { <garb3> > <com1> } ^com { <bhcom> <= <max1> >= <min1> } ^layer <garb4>) + (horizontal ^net-name nil ^min { <garb1> < <com1> } ^max <com1> ^com { <thcom> <= <max1> > <bhcom> } ^layer <garb2>) + - (horizontal ^net-name nil ^min < <com1> ^max <com1> ^com { < <thcom> > <bhcom> }) + - (horizontal ^net-name nil ^min <com1> ^max > <com1> ^com { < <thcom> > <bhcom> }) + { <t1> (to-be-routed ^net-name <nn2> ^no-of-attached-pins <nap>) } + - (vertical ^status nil ^net-name { <nn2> <> nil } ^com <com1>) + - (horizontal ^status nil ^net-name { <nn2> <> nil } ^min <= <com1> ^max >= <com1>) + (pin ^net-name <nn2> ^pin-x < <com1>) + (pin ^net-name <nn2> ^pin-x > <com1>) + { <b1> (branch-no <pn>) } + --> + (make branch-no (compute <pn> + 1)) + (modify <t1> ^no-of-attached-pins (compute <nap> - 1)) + (remove <v1> <b1>) + (make vertical ^min <min1> ^max <bhcom> ^com <com1> ^layer <lay1> ^commo <cmo1> ^compo <cpo1> ^max-net <nn2> ^min-net <mnn>) + (make vertical ^min <thcom> ^max <max1> ^com <com1> ^layer <lay1> ^commo <cmo1> ^compo <cpo1> ^min-net <nn2> ^max-net <xnn>) + (make vertical ^min <bhcom> ^max <thcom> ^com <com1> ^layer <lay1> ^commo <cmo1> ^compo <cpo1> ^net-name <nn2> ^pin-name <pn>) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com1> ^grid-y <bhcom> ^grid-layer <lay1> ^came-from north) + (make ff ^net-name <nn2> ^pin-name <pn> ^grid-x <com1> ^grid-y <thcom> ^grid-layer <lay1> ^came-from south) +) + +(p p124 + (context ^present propagate-constraint) + (ff ^net-name <nn1> ^grid-x <gx> ^grid-y <com2> ^grid-layer <lay1> ^pin-name <egarb1>) + - (vertical ^net-name nil ^min <= <com2> ^max >= <com2> ^com <gx>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com > <com2>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com < <com2>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min < <gx>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^com < <gx>) + { <h1> (horizontal ^net-name nil ^min { <min2> < <gx> } ^max { <max2> >= <gx> > <min2> } ^com <com2> ^layer <lay1> ^compo <cpo2> ^commo <cmo2> ^min-net <nn2>) } + --> + (make horizontal ^min <min2> ^max (compute <gx> - 1) ^com <com2> ^layer <lay1> ^commo <cmo2> ^compo <cpo2> ^min-net <nn2>) + (modify <h1> ^min <gx> ^min-net <nn1>) +) + +(p p125 + (context ^present propagate-constraint) + (ff ^net-name <nn1> ^grid-x <gx> ^grid-y <com2> ^grid-layer <lay1> ^pin-name <egarb1>) + - (vertical ^net-name nil ^min <= <com2> ^max >= <com2> ^com <gx>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com > <com2>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com < <com2>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^max > <gx>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^com > <gx>) + { <h1> (horizontal ^net-name nil ^min { <min2> <= <gx> } ^max { <max2> > <gx> > <min2> } ^com <com2> ^layer <lay1> ^compo <cpo2> ^commo <cmo2> ^max-net <nn2>) } + --> + (make horizontal ^min (compute <gx> + 1) ^max <max2> ^com <com2> ^layer <lay1> ^commo <cmo2> ^compo <cpo2> ^max-net <nn2>) + (modify <h1> ^max <gx> ^max-net <nn1>) +) + +(p p126 + (context ^present << propagate-constraint extend-total-verti >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> east ^net-name <nn> ^grid-x <max1> ^grid-y <com1> ^grid-layer <lay> ^pin-name <pn>) } + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <garb1> > <max1> } ^com <com1> ^layer <lay> ^compo <cpo1> ^commo <cmo1>) } + - (horizontal ^net-name nil ^min < <max1> ^max <max1> ^com <com1> ^layer <lay>) + - (vertical ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1>) + --> + (modify <h1> ^min (compute <max1> + 1) ^min-net <nn>) + (make horizontal ^min <max1> ^max (compute <max1> + 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo1> ^compo <cpo1>) + (modify <ff1> ^grid-x (compute <max1> + 1) ^came-from west ^can-chng-layer nil) +) + +(p p127 + (context ^present << propagate-constraint extend-total-verti >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> west ^net-name <nn> ^grid-x <max1> ^grid-y <com1> ^grid-layer <lay> ^pin-name <pn>) } + { <h1> (horizontal ^net-name nil ^min <garb1> ^max { <max1> > <garb1> } ^com <com1> ^layer <lay> ^compo <cpo1> ^commo <cmo1>) } + - (horizontal ^net-name nil ^min <max1> ^max > <max1> ^com <com1> ^layer <lay>) + - (vertical ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1>) + --> + (modify <h1> ^max (compute <max1> - 1) ^max-net <nn>) + (make horizontal ^max <max1> ^min (compute <max1> - 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo1> ^compo <cpo1>) + (modify <ff1> ^grid-x (compute <max1> - 1) ^came-from east ^can-chng-layer nil) +) + +(p p128 + (context ^present << propagate-constraint extend-total-verti >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> north ^net-name <nn> ^grid-x <com1> ^grid-y <max1> ^grid-layer <lay> ^pin-name <pn>) } + { <v1> (vertical ^net-name nil ^min <max1> ^max { <garb1> > <max1> } ^com <com1> ^layer <lay> ^compo <cpo1> ^commo <cmo1>) } + - (vertical ^net-name nil ^min < <max1> ^max <max1> ^com <com1> ^layer <lay>) + - (horizontal ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1>) + --> + (modify <v1> ^min (compute <max1> + 1) ^min-net <nn>) + (make vertical ^min <max1> ^max (compute <max1> + 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo1> ^compo <cpo1>) + (modify <ff1> ^grid-y (compute <max1> + 1) ^came-from south ^can-chng-layer nil) +) + +(p p129 + (context ^present << propagate-constraint extend-total-verti >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> south ^net-name <nn> ^grid-x <com1> ^grid-y <max1> ^grid-layer <lay> ^pin-name <pn>) } + { <v1> (vertical ^net-name nil ^min <garb1> ^max { <max1> > <garb1> } ^com <com1> ^layer <lay> ^compo <cpo1> ^commo <cmo1>) } + - (vertical ^net-name nil ^min <max1> ^max > <max1> ^com <com1> ^layer <lay>) + - (horizontal ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1>) + --> + (modify <v1> ^max (compute <max1> - 1) ^max-net <nn>) + (make vertical ^max <max1> ^min (compute <max1> - 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo1> ^compo <cpo1>) + (modify <ff1> ^grid-y (compute <max1> - 1) ^came-from north ^can-chng-layer nil) +) + +(p p130 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <h1> (horizontal ^status nil ^net-name <nn> ^min <min> ^max { <max> > <min> } ^com <com> ^layer <lay> ^pin-name <pn> ^max-net <gar1>) } + { <h2> (horizontal ^status nil ^net-name <nn> ^min <max> ^max { <max2> > <max> } ^com <com> ^layer <lay> ^pin-name <pn> ^max-net <nn1>) } + --> + (modify <h1> ^max <max2> ^max-net <nn1>) + (remove <h2>) +) + +(p p131 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <v1> (vertical ^status nil ^net-name <nn> ^min <min> ^max { <max> > <min> } ^com <com> ^layer <lay> ^pin-name <pn> ^max-net <gar1>) } + { <v2> (vertical ^status nil ^net-name <nn> ^min <max> ^max { <max2> > <max> } ^com <com> ^layer <lay> ^pin-name <pn> ^max-net <nn1>) } + --> + (modify <v1> ^max <max2> ^max-net <nn1>) + (remove <v2>) +) + +(p p132 + (context ^present propagate-constraint) + { <h1> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <gar1> ^max <max> ^com <com> ^layer <lay> ^pin-name <pn>) } + { <h2> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <max2> ^com <com> ^layer <lay> ^pin-name { <pn1> <> <pn> }) } + (vertical ^status nil ^net-name { <nn> <> nil } ^pin-name <pn1>) + --> + (modify <h1> ^max <max2>) + (remove <h2>) +) + +(p p133 + (context ^present propagate-constraint) + { <h1> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <gar1> ^com <com> ^layer <lay> ^pin-name <pn>) } + { <h2> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min2> ^max <min> ^com <com> ^layer <lay> ^pin-name { <pn1> <> <pn> }) } + (vertical ^status nil ^net-name { <nn> <> nil } ^pin-name <pn1>) + --> + (modify <h1> ^min <min2>) + (remove <h2>) +) + +(p p134 + (context ^present propagate-constraint) + { <v1> (vertical ^status nil ^net-name { <nn> <> nil } ^min <gar1> ^max <max> ^com <com> ^layer <lay> ^pin-name <pn>) } + { <v2> (vertical ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <max2> ^com <com> ^layer <lay> ^pin-name { <pn1> <> <pn> }) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^pin-name <pn1>) + --> + (modify <v1> ^max <max2>) + (remove <v2>) +) + +(p p135 + (context ^present propagate-constraint) + { <v1> (vertical ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <gar1> ^com <com> ^layer <lay> ^pin-name <pn>) } + { <v2> (vertical ^status nil ^net-name { <nn> <> nil } ^min <min2> ^max <min> ^com <com> ^layer <lay> ^pin-name { <pn1> <> <pn> }) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^pin-name <pn1>) + --> + (modify <v1> ^min <min2>) + (remove <v2>) +) + +(p p136 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> east ^net-name <nn> ^grid-x <max1> ^grid-y <com1> ^grid-layer <lay> ^pin-name <pn>) } + { <h1> (horizontal ^net-name nil ^min <max1> ^max { <garb1> > <max1> } ^com <com1> ^layer <lay> ^compo <cpo> ^commo <cmo>) } + - (vertical ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1> ^layer <lay>) + - (horizontal ^net-name nil ^min < <max1> ^max <max1> ^com <com1> ^layer <lay>) + --> + (modify <h1> ^min (compute <max1> + 1) ^min-net <nn>) + (make horizontal ^min <max1> ^max (compute <max1> + 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^compo <cpo> ^commo <cmo>) + (modify <ff1> ^grid-x (compute <max1> + 1) ^came-from west ^can-chng-layer nil) +) + +(p p137 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> west ^net-name <nn> ^grid-x <max1> ^grid-y <com1> ^grid-layer <lay> ^pin-name <pn>) } + { <h1> (horizontal ^net-name nil ^min <garb1> ^max { <max1> > <garb1> } ^com <com1> ^layer <lay> ^compo <cpo> ^commo <cmo>) } + - (vertical ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1> ^layer <lay>) + - (horizontal ^net-name nil ^min <max1> ^max > <max1> ^com <com1> ^layer <lay>) + --> + (modify <h1> ^max (compute <max1> - 1) ^max-net <nn>) + (make horizontal ^max <max1> ^min (compute <max1> - 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^compo <cpo> ^commo <cmo>) + (modify <ff1> ^grid-x (compute <max1> - 1) ^came-from east ^can-chng-layer nil) +) + +(p p138 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> north ^net-name <nn> ^grid-x <com1> ^grid-y <max1> ^grid-layer <lay> ^pin-name <pn>) } + { <v1> (vertical ^net-name nil ^min <max1> ^max { <garb1> > <max1> } ^com <com1> ^layer <lay> ^compo <cpo> ^commo <cmo>) } + - (horizontal ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1> ^layer <lay>) + - (vertical ^net-name nil ^min < <max1> ^max <max1> ^com <com1> ^layer <lay>) + --> + (modify <v1> ^min (compute <max1> + 1) ^min-net <nn>) + (make vertical ^min <max1> ^max (compute <max1> + 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^compo <cpo> ^commo <cmo>) + (modify <ff1> ^grid-y (compute <max1> + 1) ^came-from south ^can-chng-layer nil) +) + +(p p139 + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <ff1> (ff ^can-chng-layer no ^came-from <> south ^net-name <nn> ^grid-x <com1> ^grid-y <max1> ^grid-layer <lay> ^pin-name <pn>) } + { <v1> (vertical ^net-name nil ^min <garb1> ^max { <max1> > <garb1> } ^com <com1> ^layer <lay> ^compo <cpo> ^commo <cmo>) } + - (horizontal ^net-name nil ^min <= <com1> ^max >= <com1> ^com <max1> ^layer <lay>) + - (vertical ^net-name nil ^min <max1> ^max > <max1> ^com <com1> ^layer <lay>) + --> + (modify <v1> ^max (compute <max1> - 1) ^max-net <nn>) + (make vertical ^max <max1> ^min (compute <max1> - 1) ^com <com1> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^compo <cpo> ^commo <cmo>) + (modify <ff1> ^grid-y (compute <max1> - 1) ^came-from north ^can-chng-layer nil) +) + +(p p140 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com> ^max >= <com> ^com { >= <min> <= <max> } ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + - (included <nn> <pn1>) + (included <nn> <pn2>) + --> + (make included <nn> <pn1>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p141 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com> ^max >= <com> ^com { >= <min> <= <max> } ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + (included <nn> <pn1>) + - (included <nn> <pn2>) + --> + (make included <nn> <pn2>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p142 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <max> ^com <com> ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + (included <nn> <pn1>) + - (included <nn> <pn2>) + --> + (make included <nn> <pn2>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p143 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <egarb4> ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <max> ^com <com> ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + - (included <nn> <pn1>) + (included <nn> <pn2>) + --> + (make included <nn> <pn1>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p144 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <egarb4> ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <max> ^com <com> ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + (included <nn> <pn1>) + - (included <nn> <pn2>) + --> + (make included <nn> <pn2>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p145 + (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^max <max> ^com <com> ^layer <egarb1> ^compo <egarb2> ^commo <egarb3> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <max> ^com <com> ^pin-name { <pn2> <> <pn1> }) + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + - (included <nn> <pn1>) + (included <nn> <pn2>) + --> + (make included <nn> <pn1>) + (modify <t1> ^no-of-attached-pins (compute <nap> + 1)) +) + +(p p146 + { <c1> (context ^present << propagate-constraint check-for-routed-net find-no-of-pins-on-a-row-col >>) } + { <t1> (to-be-routed ^net-name <nn> ^no-of-attached-pins <nap>) } + { <n1> (net ^net-name <nn> ^net-no-of-pins <nap>) } + --> + (remove <c1> <t1>) + (make join-routed-net <nn>) + (modify <n1> ^net-is-routed yes) +) + +(p p147 + { <c1> (context ^present check-for-routed-net) } + --> + (remove <c1>) + (make context ^present move-ff) +) + +(p p148 + { <con> (context ^present move-ff) } + --> + (modify <con> ^present set-min-max) +) + +(p p149 + { <con> (context ^present set-min-max) } + --> + (remove <con>) + (make context ^present propagate-constraint) +) + +(p p150 + (context ^present propagate-constraint) + { <c1> (constraint ^pin-name-2 <pn>) } + - (ff ^pin-name <pn>) + --> + (remove <c1>) +) + +(p p151 + (context ^present propagate-constraint) + { <c1> (constraint ^pin-name-1 <pn>) } + - (ff ^pin-name <pn>) + --> + (remove <c1>) +) + +(p p152 + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (context ^present << propagate-constraint extend-total-verti move-ff >>) + { <ff2> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb2> ^pin-name <> <pn>) } + --> + (remove <ff1> <ff2>) +) + +(p p153 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn>) } + { <ff2> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy2> ^grid-layer <lay> ^pin-name <> <pn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy1>) + { <v1> (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1> <ff2>) + (make vertical ^min <min> ^max <gy1> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <v1> ^min <gy2> ^min-net <nn>) + (make vertical ^min <gy1> ^max <gy2> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p154 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn>) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <gy2> ^layer <lay> ^compo <egarb1> ^commo <gy1> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy2>) + { <v1> (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1>) + (make vertical ^min <min> ^max <gy1> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <v1> ^min <gy2> ^min-net <nn>) + (make vertical ^min <gy1> ^max <gy2> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p155 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy2> ^grid-layer <lay> ^pin-name <pn>) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <gy1> ^layer <lay> ^compo <gy2> ^commo <egarb1> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1>) + { <v1> (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1>) + (make vertical ^min <min> ^max <gy1> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <v1> ^min <gy2> ^min-net <nn>) + (make vertical ^min <gy1> ^max <gy2> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p156 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) } + (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> > <gx1> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^pin-name <garb1>) + { <ff2> (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> <= <max> } ^grid-y <gy> ^grid-layer <lay> ^pin-name <egarb1>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx1>) + { <h1> (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1> <ff2>) + (make horizontal ^min <min> ^max <gx1> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <h1> ^min <gx2> ^min-net <nn>) + (make horizontal ^min <gx1> ^max <gx2> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p157 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) } + (vertical ^status nil ^net-name { <nn> <> nil } ^min { <garb1> <= <gy> } ^max { <garb2> >= <gy> } ^com <gx2> ^layer <lay> ^compo <egarb1> ^commo <gx1> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-x <gx2> ^grid-y <gy>) + { <h1> (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1>) + (make horizontal ^min <min> ^max <gx1> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <h1> ^min <gx2> ^min-net <nn>) + (make horizontal ^min <gx1> ^max <gx2> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p158 + (context ^present << propagate-constraint extend-pins find-no-of-pins-on-a-row-col check-for-routed-net >>) + { <ff1> (ff ^net-name <nn> ^grid-x <gx2> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) } + (vertical ^status nil ^net-name { <nn> <> nil } ^min { <garb1> <= <gy> } ^max { <garb2> >= <gy> } ^com <gx1> ^layer <lay> ^compo <gx2> ^commo <egarb1> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy>) + { <h1> (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1>) + (make horizontal ^min <min> ^max <gx1> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <h1> ^min <gx2> ^min-net <nn>) + (make horizontal ^min <gx1> ^max <gx2> ^com <gy> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p159 + (context ^present propagate-constraint) + { <ff1> (ff ^can-chng-layer <> no ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay>) } + - (vertical ^net-name nil ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (vertical ^net-name <> nil ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + - (horizontal ^net-name <> nil ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { >= <gy> > <vmin> } ^com <gx> ^layer { <lay2> <> <lay> }) + --> + (modify <ff1> ^grid-layer <lay2> ^can-chng-layer no) +) + +(p p160 + (context ^present propagate-constraint) + { <ff1> (ff ^can-chng-layer <> no ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay>) } + - (vertical ^net-name nil ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (vertical ^net-name <> nil ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + - (horizontal ^net-name <> nil ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { >= <gx> > <hmin> } ^com <gy> ^layer { <lay2> <> lay> }) + --> + (modify <ff1> ^grid-layer <lay2> ^can-chng-layer no) +) + +(p p161 + (context ^present propagate-constraint) + { <ff1> (ff ^can-chng-layer <> no ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay>) } + - (horizontal ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + - (vertical ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + --> + (modify <ff1> ^can-chng-layer no) +) + +(p p162 + (context ^present << propagate-constraint move-ff >>) + { <ff1> (ff ^can-chng-layer <> no ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay>) } + (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + --> + (modify <ff1> ^can-chng-layer no) +) + +(p p163 + (context ^present << propagate-constraint move-ff >>) + { <ff1> (ff ^can-chng-layer <> no ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay>) } + (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + --> + (modify <ff1> ^can-chng-layer no) +) + +(p p164 + (context ^present propagate-constraint) + { <ff1> (ff ^can-chng-layer no ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay1> ^pin-name <pn>) } + { <ff2> (ff ^can-chng-layer no ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay2> ^pin-name <garb1>) } + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx2>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy1>) + { <h1> (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> >= <gx1> > <hmin> } ^com <gy1> ^layer <lay1> ^compo <hcpo> ^commo <gy2> ^min-net <hnn1>) } + { <v1> (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> >= <gy1> > <vmin> } ^com <gx2> ^layer <lay2> ^compo <gx1> ^commo <vcmo> ^min-net <vnn1>) } + --> + (make horizontal ^min <hmin> ^max <gx2> ^com <gy1> ^commo <gy2> ^compo <hcpo> ^layer <lay1> ^min-net <hnn1> ^max-net <nn>) + (modify <h1> ^min <gx1> ^min-net <nn>) + (make vertical ^min <vmin> ^max <gy2> ^com <gx2> ^commo <vcmo> ^compo <gx1> ^layer <lay2> ^min-net <vnn1> ^max-net <nn>) + (modify <v1> ^min <gy1> ^min-net <nn>) + (remove <ff1> <ff2>) + (make horizontal ^min <gx2> ^max <gx1> ^com <gy1> ^commo <gy2> ^compo <hcpo> ^layer <lay1> ^net-name <nn> ^pin-name <pn>) + (make vertical ^min <gy2> ^max <gy1> ^com <gx2> ^commo <vcmo> ^compo <gx1> ^layer <lay2> ^net-name <nn> ^pin-name <pn>) +) + +(p p165 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <garb1> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min <garb2> ^max { <max> > <garb2> } ^com <com> ^layer <lay> ^max-net <> <nn>) } + --> + (modify <v1> ^max-net <nn>) +) + +(p p166 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <min> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min <min> ^max { <garb2> > <min> } ^com <com> ^layer <lay> ^min-net <> <nn>) } + --> + (modify <v1> ^min-net <nn>) +) + +(p p167 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <max> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min { <garb1> < <max> } ^max <max> ^com { >= <hmin> <= <hmax> } ^layer <lay> ^max-net <> <nn>) } + --> + (modify <v1> ^max-net <nn>) +) + +(p p168 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <min> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <v1> (vertical ^net-name nil ^min <min> ^max { <garb1> > <min> } ^com { >= <hmin> <= <hmax> } ^layer <lay> ^min-net <> <nn>) } + --> + (modify <v1> ^min-net <nn>) +) + +(p p169 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <garb1> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <h1> (horizontal ^net-name nil ^min <garb2> ^max { <max> > <garb2> } ^com <com> ^layer <lay> ^max-net <> <nn>) } + --> + (modify <h1> ^max-net <nn>) +) + +(p p170 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <min> ^com <com> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <h1> (horizontal ^net-name nil ^min <min> ^max { <garb2> > <min> } ^com <com> ^layer <lay> ^min-net <> <nn>) } + --> + (modify <h1> ^min-net <nn>) +) + +(p p171 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <max> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <h1> (horizontal ^net-name nil ^min <garb1> ^max { <max> > <garb1> } ^com { >= <vmin> <= <vmax> } ^layer <lay> ^max-net <> <nn>) } + --> + (modify <h1> ^max-net <nn>) +) + +(p p172 + (context ^present << propagate-constraint extend-pins set-min-max >>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <min> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + { <h1> (horizontal ^net-name nil ^min <min> ^max { <garb1> > <min> } ^com { >= <vmin> <= <vmax> } ^layer <lay> ^min-net <> <nn>) } + --> + (modify <h1> ^min-net <nn>) +) + +(p p173 + (context ^present propagate-constraint) + { <ff1> (ff ^can-chng-layer no ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn>) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <garb1> <= <gx> } ^max { <garb2> >= <gx> } ^com <gy2> ^layer <garb3> ^compo <garb4> ^commo <gy1> ^pin-name <> <pn>) + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^com <gy2>) + - (vertical ^net-name { <> nil <> <nn> } ^min <= <gy2> ^max >= <gy2> ^com <gx>) + { <v1> (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1>) } + --> + (remove <ff1>) + (make vertical ^min <min> ^max <gy1> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (modify <v1> ^min <gy2> ^min-net <nn>) + (make vertical ^min <gy1> ^max <gy2> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <lay> ^net-name <nn> ^pin-name <pn>) +) + +(p p174 + (join-routed-net <nn>) + { <h1> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <com> ^layer <lay> ^compo <garb1> ^commo <garb2>) } + { <h2> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <max2> ^com <com> ^layer <lay> ^compo <garb3> ^commo <garb4>) } + --> + (modify <h1> ^max <max2>) + (remove <h2>) +) + +(p p175 + (join-routed-net <nn>) + { <v1> (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <max> ^com <com> ^layer <lay> ^compo <garb2> ^commo <garb3>) } + { <v2> (vertical ^status nil ^net-name { <nn> <> nil } ^min <max> ^max <max2> ^com <com> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + --> + (modify <v1> ^max <max2>) + (remove <v2>) +) + +(p p176 + { <j1> (join-routed-net <nn>) } + --> + (remove <j1>) + (make move-via <nn>) +) + +(p p177 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <vlayer> ^pin-name <egarb1>) + (horizontal ^net-name nil ^min <hmin2> ^max { <gx> > <hmin2> } ^com <vmax> ^layer <vlayer> ^compo <egarb8> ^commo <egarb9>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { < <vmax> > <gy> }) + { <v1> (vertical ^net-name nil ^min { <garb1> <= <gy> } ^max { <vmax> > <garb1> > <gy> } ^com <gx> ^layer <vlayer> ^commo <cmo> ^compo <cpo> ^max-net <maxn>) } + (horizontal ^net-name { <> <nn> <> nil } ^min { <hmin1> <= <gx> } ^max >= <gx> ^com <vmax> ^layer <> <vlayer>) + (vertical ^net-name { <> <nn> <> nil } ^min <= <vmax> ^max >= <vmax> ^com { <vcom> < <gx> >= <hmin1> >= <hmin2> } ^layer <vlayer>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com <vmax>) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { < <vmax> > <gy> } ^max-net nil) + - (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <gx>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmax> ^max > <vmax> ^com <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <gx> ^max > <gx> ^com <vmax>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { < <vmax> > <gy> } ^min-net nil) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { < <vmax> > <gy> }) + - (vertical ^net-name nil ^min < <vmax> ^max > <vmax> ^com { < <gx> > <vcom> }) + - (vertical ^net-name nil ^min < <vmax> ^max <vmax> ^com { < <gx> > <vcom> } ^max-net nil) + - (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com { < <gx> > <vcom> } ^min-net nil) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <vmax> ^max >= <vmax> ^com { < <gx> > <vcom> }) + --> + (make vertical ^min (compute <gy> + 1) ^max <vmax> ^com <gx> ^commo <cmo> ^compo <cpo> ^layer <vlayer> ^max-net <maxn>) + (modify <v1> ^max <gy> ^max-net <nn>) +) + +(p p178 + (context ^present propagate-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <layer> ^pin-name <pn>) + { <h1> (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> > <gx> > <hmin> } ^com <gy> ^layer <layer> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + (vertical ^net-name { <> <nn> <> nil } ^min <cpo> ^max { <garb2> >= <cpo> } ^com <vcom> ^layer <layer1> ^compo <vcpo> ^commo <gx>) + (horizontal ^net-name { <> <nn> <> nil } ^min { <garb3> <= <vcom> } ^max { <garb4> >= <vcom> } ^com <cpo> ^layer <> <layer1> ^compo <garb5> ^commo <gy>) + (vertical ^net-name { <> <nn> <> nil } ^min { <garb6> <= <cmo> } ^max <cmo> ^com <vcom> ^layer <layer2> ^compo <vcpo> ^commo <gx>) + (horizontal ^net-name { <> <nn> <> nil } ^min { <garb7> <= <vcom> } ^max { <garb8> >= <vcom> } ^com <cmo> ^layer <> <layer2> ^compo <gy> ^commo <garb9>) + (vertical ^net-name { <> <nn> <> nil } ^min { <garb13> <= <gy> } ^max { <garb14> >= <gy> } ^com <vcpo> ^layer <layer3> ^compo <garb10> ^commo <vcom>) + (horizontal ^net-name { <> <nn> <> nil } ^min { <garb11> <= <vcpo> } ^max { <garb12> >= <vcpo> } ^com <gy> ^layer <> <layer3> ^compo <cpo> ^commo <cmo>) + --> + (make horizontal ^min (compute <gx> + 1) ^max <hmax> ^com <gy> ^compo <cpo> ^commo <cmo> ^layer <layer> ^max-net <mn>) + (modify <h1> ^max <gx> ^max-net <nn>) +) + +(p p179 + (context ^present propagate-constraint) + { <ff1> (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^pin-name <pn>) } + (vertical ^net-name { <> <nn> <> nil } ^min { <vmin> <= <gy> } ^max { <vmax> >= <gy> } ^com <vcom> ^layer <lay2> ^compo <garb1> ^commo <gx>) + (vertical ^net-name { <> <nn> <> nil } ^min { <vmax2> > <gy> <= <vmax> } ^max <garb4> ^com <gx> ^layer <lay4>) + (vertical ^net-name { <> <nn> <> nil } ^min <garb2> ^max { <vmin2> < <gy> >= <vmin> } ^com <gx> ^layer <lay3>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmin2> < <gy> }) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmin2> < <gy> } ^layer <> <lay2> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmin2> < <gy> } ^max-net nil) + - (horizontal ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { > <vmin2> < <gy> }) + (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <vmin2> ^layer <> <lay3>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmax2> }) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmax2> } ^layer <> <lay2> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmax2> } ^max-net nil) + - (horizontal ^net-name <nn> ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmax2> }) + (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <vmax2> ^layer <> <lay4>) + { <h1> (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> >= <vcom> > <hmin> } ^com <gy> ^layer { <lay5> <> <lay2> } ^compo <hcpo> ^commo <hcmo> ^max-net <mn>) } + --> + (make horizontal ^layer <lay5> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <nn> ^max-net <mn> ^min <vcom> ^max <hmax>) + (modify <h1> ^max <gx> ^max-net <nn>) + (make horizontal ^layer <lay5> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn> ^min <gx> ^max <vcom>) + (modify <ff1> ^grid-x <vcom> ^grid-layer <lay5> ^can-chng-layer no) +) + +(p p180 + (context ^present propagate-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <vmax> ^com <vcom> ^layer <lay1> ^compo <cpo> ^commo <cmo>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <garb2> <= <vcom> } ^max { <garb3> >= <vcom> } ^com <vmax> ^layer { <garb4> <> <lay1> }) + (vertical ^net-name { <nn1> <> <nn> <> nil } ^min { <vmin> > <vmax> } ^max <garb5> ^com <vcom> ^layer <lay2>) + (horizontal ^net-name { <nn1> <> nil } ^min { <garb6> <= <vcom> } ^max { <garb7> >= <vcom> } ^com <vmin> ^layer { <garb8> <> <lay2> }) + (vertical ^net-name { <> <nn> <> nil } ^min { <vmin2> <= <vmax> } ^max { <vmax2> >= <vmin> } ^com <cpo> ^layer <lay3>) + { <v1> (vertical ^net-name nil ^min <vmax> ^max { <vmax3> > <vmax> } ^com <vcom> ^layer <lay3>) } + - (vertical ^net-name nil ^min <vmax3> ^com <vcom>) + - (horizontal ^net-name nil ^min < <vcom> ^max > <vcom> ^com { > <vmax> <= <vmax3> }) + - (horizontal ^net-name nil ^min <vcom> ^max > <vcom> ^com { > <vmax> <= <vmax3> } ^layer <> <lay3> ^min-net nil) + - (horizontal ^net-name nil ^min < <vcom> ^max <vcom> ^com { > <vmax> <= <vmax3> } ^max-net nil) + - (horizontal ^net-name { <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com { > <vmax> <= <vmax3> }) + --> + (modify <v1> ^min (compute <vmax> + 1) ^min-net nil) +) + +(p p181 + (context ^present propagate-constraint) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) } + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> } ^grid-y <garb1> ^grid-layer <lay> ^pin-name <> <pn>) + - (vertical ^com { > <gx> < <gx2> }) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { <egarb1> > <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + - (vertical ^net-name nil ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2>) + --> + (modify <h1> ^min (compute <gx> + 1) ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <gx> ^com <gy> ^max (compute <gx> + 1) ^commo <hcmo> ^compo <hcpo> ^layer <lay>) + (modify <ff1> ^grid-x (compute <gx> + 1) ^came-from west) +) + +(p p182 + (context ^present propagate-constraint) + { <v3> (vertical ^net-name nil ^min <vmin2> ^max { <vmax2> > <vmin2> } ^com <vcom> ^layer <garb1> ^compo <vcpo> ^commo <egarb1>) } + (congestion ^direction row ^coordinate <vmax2> ^como <vmin2>) + - (horizontal ^status nil ^min < <vcom> ^max >= <vcom> ^com { <= <vmax2> >= <vmin2> }) + - (vertical ^status nil ^min <vmax2> ^max > <vmax2> ^com <vcom>) + - (vertical ^status nil ^max <vmin2> ^min < <vmin2> ^com <vcom>) + (vertical ^net-name nil ^min { <vmin> <= <vmin2> } ^max { > <vmin> >= <vmax2> } ^com <vcpo> ^layer <lay>) + (horizontal ^net-name nil ^min <vcom> ^max { <egarb2> > <vcom> } ^com <vmax2> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) + (horizontal ^net-name nil ^min <vcom> ^max { <egarb5> > <vcom> } ^com <vmin2> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) + --> + (remove <v3>) +) + +(p p183 + (context ^present propagate-constraint) + { <v3> (vertical ^net-name nil ^min <vmin2> ^max { <vmax2> > <vmin2> } ^com <vcom> ^layer <garb1> ^compo <garb2> ^commo <vcmo>) } + (congestion ^direction row ^coordinate <vmax2> ^como <vmin2>) + - (horizontal ^status nil ^min <= <vcom> ^max > <vcom> ^com { <= <vmax2> >= <vmin2> }) + - (vertical ^status nil ^min <vmax2> ^max > <vmax2> ^com <vcom>) + - (vertical ^status nil ^max <vmin2> ^min < <vmin2> ^com <vcom>) + (vertical ^net-name nil ^min { <vmin> <= <vmin2> } ^max { > <vmin> >= <vmax2> } ^com <vcmo> ^layer <lay>) + (horizontal ^net-name nil ^min <egarb1> ^max { <vcom> > <egarb1> } ^com <vmax2> ^layer <lay> ^compo <egarb2> ^commo <egarb3>) + (horizontal ^net-name nil ^min <egarb6> ^max { <vcom> > <egarb6> } ^com <vmin2> ^layer <lay> ^compo <egarb4> ^commo <egarb5>) + --> + (remove <v3>) +) + +(p p184 + (context ^present propagate-constraint) + { <h3> (horizontal ^net-name nil ^min <hmin2> ^max { <hmax2> > <hmin2> } ^com <hcom> ^layer <garb1> ^compo <hcpo> ^commo <egarb1>) } + (congestion ^direction col ^coordinate <hmax2> ^como <hmin2>) + - (vertical ^status nil ^min < <hcom> ^max >= <hcom> ^com { <= <hmax2> >= <hmin2> }) + - (horizontal ^status nil ^min <hmax2> ^max > <hmax2> ^com <hcom>) + - (horizontal ^status nil ^max <hmin2> ^min < <hmin2> ^com <hcom>) + (horizontal ^net-name nil ^min { <hmin> <= <hmin2> } ^max { > <hmin> >= <hmax2> } ^com <hcpo> ^layer <lay>) + (vertical ^net-name nil ^min <hcom> ^max { <egarb2> > <hcom> } ^com <hmax2> ^layer <lay> ^compo <egarb3> ^commo <egarb4>) + (vertical ^net-name nil ^min <hcom> ^max { <egarb5> > <hcom> } ^com <hmin2> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) + --> + (remove <h3>) +) + +(p p185 + (context ^present propagate-constraint) + { <h3> (horizontal ^net-name nil ^min <hmin2> ^max { <hmax2> > <hmin2> } ^com <hcom> ^layer <garb1> ^compo <garb2> ^commo <hcmo>) } + (congestion ^direction col ^coordinate <hmax2> ^como <hmin2>) + - (vertical ^status nil ^min <= <hcom> ^max > <hcom> ^com { <= <hmax2> >= <hmin2> }) + - (horizontal ^status nil ^min <hmax2> ^max > <hmax2> ^com <hcom>) + - (horizontal ^status nil ^max <hmin2> ^min < <hmin2> ^com <hcom>) + (horizontal ^net-name nil ^min { <hmin> <= <hmin2> } ^max { > <hmin> >= <hmax2> } ^com <hcmo> ^layer <lay>) + (vertical ^net-name nil ^min <egarb1> ^max { <hcom> > <egarb1> } ^com <hmax2> ^layer <lay> ^compo <egarb3> ^compo <egarb4>) + (vertical ^net-name nil ^min <egarb5> ^max { <hcom> > <egarb5> } ^com <hmin2> ^layer <lay> ^compo <egarb6> ^commo <egarb7>) + --> + (remove <h3>) +) + +(p p538 + (finally-routed <nn>) + { <i1> (included <nn>) } + --> + (remove <i1>) +) + +(p p539 + (finally-routed <nn>) + { <ff1> (ff ^net-name <nn>) } + --> + (remove <ff1>) +) + +(p p540 + (finally-routed <nn>) + { <c1> (constraint ^constraint-type << vertical horizontal >> ^net-name-1 <nn>) } + --> + (remove <c1>) +) + +(p p541 + (finally-routed <nn>) + { <c1> (constraint ^constraint-type << vertical horizontal >> ^net-name-2 <nn>) } + --> + (remove <c1>) +) + +(p p542 + (finally-routed <nn>) + { <c> (<< horizontal-cycle vertical-cycle >> <nn>) } + --> + (remove <c>) +) + +(p p543 + (finally-routed <nn>) + { <c1> (constraint ^constraint-type << vertical horizontal >> ^net-name-2 <nn>) } + --> + (remove <c1>) +) + +(p p544 + (finally-routed <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <garb1> ^commo <garb2>) + { <h1> (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { <hmax> > <hmin> >= <vcom> } ^com { <hcom> >= <vmin> <= <vmax> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <nn1>) } + --> + (make horizontal ^min <hmin> ^max (compute <vcom> - 1) ^com <hcom> ^compo <hcpo> ^commo <hcmo> ^layer <lay> ^min-net <nn1>) + (modify <h1> ^min (compute <vcom> + 1) ^min-net nil) +) + +(p p545 + (finally-routed <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <garb1> ^commo <garb2>) + { <v1> (vertical ^net-name nil ^min { <vmin> <= <hcom> } ^max { <vmax> > <vmin> >= <hcom> } ^com { <vcom> >= <hmin> <= <hmax> } ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <nn1>) } + --> + (make vertical ^min <vmin> ^max (compute <hcom> - 1) ^com <vcom> ^compo <vcpo> ^commo <vcmo> ^layer <lay> ^min-net <nn1>) + (modify <v1> ^min (compute <hcom> + 1) ^min-net nil) +) + +(p p546 + (finally-routed <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <rmax> ^com <com> ^layer <lay> ^compo <garb4> ^commo <garb3>) + { <v1> (vertical ^net-name nil ^min <rmax> ^max { <garb2> > <rmax> } ^com <com> ^layer <lay> ^compo <garb6> ^commo <garb5>) } + --> + (modify <v1> ^min (compute <rmax> + 1) ^min-net nil) +) + +(p p547 + (finally-routed <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <rmin> ^max <garb1> ^com <com> ^layer <lay> ^compo <garb3> ^commo <garb4>) + { <v1> (vertical ^net-name nil ^min <garb2> ^max { <rmin> > <garb2> } ^com <com> ^layer <lay> ^compo <garb5> ^commo <garb6>) } + --> + (modify <v1> ^max (compute <rmin> - 1) ^max-net nil) +) + +(p p548 + (finally-routed <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max <rmax> ^com <com> ^layer <lay> ^compo <garb3> ^commo <garb4>) + { <h1> (horizontal ^net-name nil ^min <rmax> ^max { <garb2> > <rmax> } ^com <com> ^layer <lay> ^compo <garb5> ^commo <garb6>) } + --> + (modify <h1> ^min (compute <rmax> + 1) ^min-net nil) +) + +(p p549 + (finally-routed <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <rmin> ^max <garb1> ^com <com> ^layer <lay> ^compo <garb3> ^commo <garb4>) + { <h1> (horizontal ^net-name nil ^min <garb2> ^max { <rmin> > <garb2> } ^com <com> ^layer <lay> ^compo <garb5> ^commo <garb6>) } + --> + (modify <h1> ^max (compute <rmin> - 1) ^max-net nil) +) + +(p p550 + { <f1> (finally-routed <nn>) } + --> + (remove <f1>) + (make context ^present remove-routed-net-segments <nn>) +) + +(p p551 + (context ^present remove-routed-net-segments <nn>) + { <h1> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <c> ^layer <lay> ^compo <garb1> ^commo <garb2>) } + --> + (modify <h1> ^status routed) + (write (crlf) |hor | <nn> <min> <max> <c> <lay>) +) + +(p p552 + (context ^present remove-routed-net-segments <nn>) + { <v1> (vertical ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <c> ^layer <lay> ^compo <garb1> ^commo <garb2>) } + --> + (modify <v1> ^status routed) + (write (crlf) |ver | <nn> <min> <max> <c> <lay>) +) + +(p p553 + (context ^present remove-routed-net-segments <nn>) + { <h> (horizontal-s ^net-name <nn>) } + --> + (remove <h>) +) + +(p p554 + (context ^present remove-routed-net-segments <nn>) + { <v> (vertical-s ^net-name <nn>) } + --> + (remove <v>) +) + +(p p555 + (context ^present remove-routed-net-segments <nn>) + { <p> (pin ^net-name <nn>) } + --> + (remove <p>) +) + +(p p556 + (context ^present remove-routed-net-segments <nn>) + { <n> (net ^net-name <nn>) } + --> + (remove <n>) +) + +(p p557 + { <c1> (context ^present remove-routed-net-segments) } + --> + (remove <c1>) + (make context ^present check-for-routed-net) +) + +(p p32 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-top-pins 1 ^no-of-bottom-pins 1) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + { <v> (vertical ^net-name nil ^min <gy2> ^max > <gy2> ^com <gx2> ^layer <lay> ^commo <cmo> ^compo <gx1> ^min-net <garb2>) } + - (horizontal ^net-name nil ^min <= <gx2> ^max >= <gx1> ^com <gy2> ^layer <lay>) + (congestion ^direction row ^coordinate <gy3> ^como <gy2>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy3> ^max >= <gy3> ^com <gx2> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy3> ^layer <lay>) + --> + (modify <v> ^min <gy3> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn2> ^min <gy2> ^max <gy3> ^com <gx2> ^compo <gx1> ^commo <cmo> ^layer <lay>) + (modify <ff> ^grid-y <gy3> ^can-chng-layer nil ^came-from south) +) + +(p p33 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-top-pins 1 ^no-of-bottom-pins 1) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + { <v> (vertical ^net-name nil ^min < <gy1> ^max <gy1> ^com <gx1> ^layer <lay> ^commo <gx2> ^compo <cpo> ^min-net <garb2>) } + - (horizontal ^net-name nil ^min <= <gx2> ^max >= <gx1> ^com <gy1> ^layer <lay>) + (congestion ^direction row ^coordinate <gy1> ^como <gy3>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy3> ^max >= <gy3> ^com <gx1> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy3> ^layer <lay>) + --> + (modify <v> ^max <gy3> ^max-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn1> ^min <gy3> ^max <gy1> ^com <gx1> ^compo <cpo> ^commo <gx2> ^layer <lay>) + (modify <ff> ^grid-y <gy3> ^can-chng-layer nil ^came-from north) +) + +(p p34 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-top-pins 1 ^no-of-bottom-pins 1) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + { <v> (vertical ^net-name nil ^min <gy2> ^max > <gy2> ^com <gx2> ^layer <lay> ^commo <gx1> ^compo <cpo> ^min-net <garb2>) } + - (horizontal ^net-name nil ^min <= <gx1> ^max >= <gx2> ^com <gy2> ^layer <lay>) + (congestion ^direction row ^coordinate <gy3> ^como <gy2>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy3> ^max >= <gy3> ^com <gx2> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy3> ^layer <lay>) + --> + (modify <v> ^min <gy3> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn2> ^min <gy2> ^max <gy3> ^com <gx2> ^compo <cpo> ^commo <gx1> ^layer <lay>) + (modify <ff> ^grid-y <gy3> ^can-chng-layer nil ^came-from south) +) + +(p p35 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-top-pins 1 ^no-of-bottom-pins 1) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + { <v> (vertical ^net-name nil ^min < <gy1> ^max <gy1> ^com <gx1> ^layer <lay> ^commo <cmo> ^compo <gx2> ^min-net <garb2>) } + - (horizontal ^net-name nil ^min <= <gx1> ^max >= <gx2> ^com <gy1> ^layer <lay>) + (congestion ^direction row ^coordinate <gy1> ^como <gy3>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy3> ^max >= <gy3> ^com <gx1> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy3> ^layer <lay>) + --> + (modify <v> ^max <gy3> ^max-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn1> ^min <gy3> ^max <gy1> ^com <gx1> ^compo <gx2> ^commo <cmo> ^layer <lay>) + (modify <ff> ^grid-y <gy3> ^can-chng-layer nil ^came-from north) +) + +(p p36 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-right-pins 1 ^no-of-left-pins 1) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + { <v> (horizontal ^net-name nil ^min <gx2> ^max > <gx2> ^com <gy2> ^layer <lay> ^commo <cmo> ^compo <gy1> ^min-net <garb2>) } + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com <gx2> ^layer <lay>) + (congestion ^direction col ^coordinate <gx3> ^como <gx2>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx3> ^max >= <gx3> ^com <gy2> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx3> ^layer <lay>) + --> + (modify <v> ^min <gx3> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn2> ^min <gx2> ^max <gx3> ^com <gy2> ^compo <gy1> ^commo <cmo> ^layer <lay>) + (modify <ff> ^grid-x <gx3> ^can-chng-layer nil ^came-from west) +) + +(p p37 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-right-pins 1 ^no-of-left-pins 1) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + { <v> (horizontal ^net-name nil ^min < <gx1> ^max <gx1> ^com <gy1> ^layer <lay> ^commo <gy2> ^compo <cpo> ^min-net <garb2>) } + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com <gx1> ^layer <lay>) + (congestion ^direction col ^coordinate <gx1> ^como <gx3>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx3> ^max >= <gx3> ^com <gy1> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx3> ^layer <lay>) + --> + (modify <v> ^max <gx3> ^max-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn1> ^min <gx3> ^max <gx1> ^com <gy1> ^compo <cpo> ^commo <gy2> ^layer <lay>) + (modify <ff> ^grid-x <gx3> ^can-chng-layer nil ^came-from east) +) + +(p p38 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-right-pins 1 ^no-of-left-pins 1) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + { <v> (horizontal ^net-name nil ^min < <gx2> ^max <gx2> ^com <gy2> ^layer <lay> ^commo <cmo> ^compo <gx1> ^min-net <garb2>) } + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com <gx2> ^layer <lay>) + (congestion ^direction col ^coordinate <gx2> ^como <gx3>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx3> ^max >= <gx3> ^com <gy2> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx3> ^layer <lay>) + --> + (modify <v> ^max <gx3> ^max-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn2> ^min <gx3> ^max <gx2> ^com <gy2> ^compo <gy1> ^commo <cmo> ^layer <lay>) + (modify <ff> ^grid-x <gx3> ^can-chng-layer nil ^came-from east) +) + +(p p39 + (context ^present propagate-constraint) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes ^no-of-right-pins 1 ^no-of-left-pins 1) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + { <v> (horizontal ^net-name nil ^min <gx1> ^max > <gx1> ^com <gy1> ^layer <lay> ^commo <gy2> ^compo <cpo> ^min-net <garb2>) } + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com <gx1> ^layer <lay>) + (congestion ^direction col ^coordinate <gx3> ^como <gx1>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx3> ^max >= <gx3> ^com <gy1> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx3> ^layer <lay>) + --> + (modify <v> ^min <gx3> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn1> ^min <gx1> ^max <gx3> ^com <gy1> ^compo <cpo> ^commo <gy2> ^layer <lay>) + (modify <ff> ^grid-x <gx3> ^can-chng-layer nil ^came-from west) +) + +(p p40 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cpo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cmo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p41 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cpo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cmo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p42 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cmo> ^layer <lay>) + (last-row <gy>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p43 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cmo> ^layer <lay>) + (last-row <gy>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p44 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cpo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay> ^commo 0) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p45 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cpo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay> ^commo 0) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p46 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cpo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <h1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cmo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <vmax2> ^max-net nil) +) + +(p p47 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cpo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cmo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p48 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cmo> ^layer <lay>) + (last-col <gx>) + --> + (modify <v1> ^max <vmax2> ^max-net nil) +) + +(p p49 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cmo> ^layer <lay>) + (last-col <gx>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p50 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cpo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay> ^commo 0) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^max <vmax2> ^max-net nil) +) + +(p p51 + (context ^present propagate-constraint) + (ff ^can-chng-layer <> no ^net-name <nn1> ^grid-x <gx> ^grid-y <gy> ^grid-layer <ttgarb>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cpo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay> ^commo 0) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p52 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <gx> ^max <ppgarb> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cpo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cmo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p53 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gx> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cpo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cmo> ^layer <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p54 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <gx> ^max <ppgarb> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cmo> ^layer <lay>) + (last-row <gy>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p55 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gx> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cmo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay>) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cmo> ^layer <lay>) + (last-row <gy>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p56 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <gx> ^max <ppgarb> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <hmax1> < <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <gx> ^max >= <hmax1> ^com <cpo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <hmax1> < <gx> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min { < <gx> >= <hmax1> } ^max <gx> ^com <gy> ^layer <lay> ^commo 0) } + (vertical ^com <hmin2> ^compo <garb10> ^commo <hmax1>) + (vertical ^com <hmax2> ^compo <gx> ^commo <garb11>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin2> ^max >= <hmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <hmax2> ^max-net nil) +) + +(p p57 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gx> ^com <gy>) + (horizontal ^net-name { <> nil <> <nn1> } ^min { <hmin1> > <gx> } ^max <garb1> ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <> <lay>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmin1> ^max >= <gx> ^com <cpo> ^layer <lay>) + - (vertical ^status nil ^net-name { <nn1> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min < <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay>) + - (vertical ^net-name nil ^min <gy> ^max > <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^min-net nil) + - (vertical ^net-name nil ^min < <gy> ^max <gy> ^com { > <gx> < <hmin1> } ^layer <> <lay> ^max-net nil) + { <h1> (horizontal ^net-name nil ^min <gx> ^max { > <gx> <= <hmin1> } ^com <gy> ^layer <lay> ^commo 0) } + (vertical ^com <hmin2> ^compo <hmin1> ^commo <garb10>) + (vertical ^com <hmax2> ^compo <garb11> ^commo <gx>) + (horizontal ^net-name { <> nil <> <nn1> } ^min <= <hmax2> ^max >= <hmin2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^min <hmax2> ^min-net nil) +) + +(p p58 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <gy> ^max <ppgarb> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cpo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <h1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cmo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cpo> ^layer <lay>) + --> + (modify <h1> ^max <vmax2> ^max-net nil) +) + +(p p59 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gy> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cpo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cmo> ^layer <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p60 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <gy> ^max <ppgarb> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cmo> ^layer <lay>) + (last-col <gx>) + --> + (modify <v1> ^max <vmax2> ^max-net nil) +) + +(p p61 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gy> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cmo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay>) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cmo> ^layer <lay>) + (last-col <gx>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p62 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <gy> ^max <ppgarb> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min <garb1> ^max { <vmax1> < <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <gy> ^max >= <vmax1> ^com <cpo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <vmax1> < <gy> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min { < <gy> >= <vmax1> } ^max <gy> ^com <gx> ^layer <lay> ^commo 0) } + (horizontal ^com <vmin2> ^compo <garb10> ^commo <vmax1>) + (horizontal ^com <vmax2> ^compo <gy> ^commo <garb11>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin2> ^max >= <vmax2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^max <vmax2> ^max-net nil) +) + +(p p63 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <ppgarb> ^max <gy> ^com <gx>) + (vertical ^net-name { <> nil <> <nn1> } ^min { <vmin1> > <gy> } ^max <garb1> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <> <lay>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmin1> ^max >= <gy> ^com <cpo> ^layer <lay>) + - (horizontal ^status nil ^net-name { <nn1> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay>) + - (horizontal ^net-name nil ^min <gx> ^max > <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^min-net nil) + - (horizontal ^net-name nil ^min < <gx> ^max <gx> ^com { > <gy> < <vmin1> } ^layer <> <lay> ^max-net nil) + { <v1> (vertical ^net-name nil ^min <gy> ^max { > <gy> <= <vmin1> } ^com <gx> ^layer <lay> ^commo 0) } + (horizontal ^com <vmin2> ^compo <vmin1> ^commo <garb10>) + (horizontal ^com <vmax2> ^compo <garb11> ^commo <gy>) + (vertical ^net-name { <> nil <> <nn1> } ^min <= <vmax2> ^max >= <vmin2> ^com <cpo> ^layer <lay>) + --> + (modify <v1> ^min <vmax2> ^min-net nil) +) + +(p p64 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max { <hmax> > <vcom> } ^com <vmax> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min < <vmax> ^max >= <vmax> ^com <vcmo> ^layer <lay> ^compo <vcom> ^commo <garb1>) + (vertical ^net-name { <nn2> <> <nn1> <> nil } ^min < <vmax> ^max >= <vmax> ^com <vcpo> ^layer <lay> ^compo <garb2> ^commo <vcom>) + (horizontal ^net-name nil ^min < <vcom> ^max > <vcom> ^com <hcmo> ^layer <lay>) + - (vertical ^status nil ^min <vmax> ^max > <vmax> ^com <vcom>) + - (horizontal ^status nil ^min { <temp> <= <vcom> } ^max { > <temp> >= <vcom> } ^com <vmax> ^layer <> <lay>) + --> + (modify <v> ^max <hcmo> ^max-net nil) + (make (substr <h> 1 inf) ^max <vcmo> ^max-net <nn1>) + (modify <h> ^min <vcpo> ^min-net <nn2>) +) + +(p p65 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max { <hmax> > <vcom> } ^com <vmin> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min <= <vmin> ^max > <vmin> ^com <vcmo> ^layer <lay> ^compo <vcom> ^commo <garb1>) + (vertical ^net-name { <nn2> <> <nn1> <> nil } ^min <= <vmin> ^max > <vmin> ^com <vcpo> ^layer <lay> ^compo <garb2> ^commo <vcom>) + (horizontal ^net-name nil ^min < <vcom> ^max > <vcom> ^com <hcpo> ^layer <lay>) + - (vertical ^status nil ^min < <vmin> ^max <vmin> ^com <vcom>) + - (horizontal ^status nil ^min { <temp> <= <vcom> } ^max { > <temp> >= <vcom> } ^com <vmin> ^layer <> <lay>) + --> + (modify <v> ^min <hcpo> ^min-net nil) + (make (substr <h> 1 inf) ^max <vcmo> ^max-net <nn1>) + (modify <h> ^min <vcpo> ^min-net <nn2>) +) + +(p p66 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min { <vmin> < <hcom> } ^max { <vmax> > <hcom> } ^com <hmax> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min < <hmax> ^max >= <hmax> ^com <hcmo> ^layer <lay> ^compo <hcom> ^commo <garb1>) + (horizontal ^net-name { <nn2> <> <nn1> <> nil } ^min < <hmax> ^max >= <hmax> ^com <hcpo> ^layer <lay> ^compo <garb2> ^commo <hcom>) + (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com <vcmo> ^layer <lay>) + - (horizontal ^status nil ^min <hmax> ^max > <hmax> ^com <hcom>) + - (vertical ^status nil ^min { <temp> <= <hcom> } ^max { > <temp> >= <hcom> } ^com <hmax> ^layer <> <lay>) + --> + (modify <h> ^max <vcmo> ^max-net nil) + (make (substr <v> 1 inf) ^max <hcmo> ^max-net <nn1>) + (modify <v> ^min <hcpo> ^min-net <nn2>) +) + +(p p67 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min { <vmin> < <hcom> } ^max { <vmax> > <hcom> } ^com <hmin> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min <= <hmin> ^max > <hmin> ^com <hcmo> ^layer <lay> ^compo <hcom> ^commo <garb1>) + (horizontal ^net-name { <nn2> <> <nn1> <> nil } ^min <= <hmin> ^max > <hmin> ^com <hcpo> ^layer <lay> ^compo <garb2> ^commo <hcom>) + (vertical ^net-name nil ^min < <hcom> ^max > <hcom> ^com <vcpo> ^layer <lay>) + - (horizontal ^status nil ^min < <hmin> ^max <hmin> ^com <hcom>) + - (vertical ^status nil ^min { <temp> <= <hcom> } ^max { > <temp> >= <hcom> } ^com <hmin> ^layer <> <lay>) + --> + (modify <h> ^min <vcpo> ^min-net nil) + (make (substr <v> 1 inf) ^max <hcmo> ^max-net <nn1>) + (modify <v> ^min <hcpo> ^min-net <nn2>) +) + +(p p68 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max <vcom> ^com <vmax> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min < <vmax> ^max >= <vmax> ^com <vcmo> ^layer <lay> ^compo <vcom> ^commo <garb1>) + (horizontal ^net-name nil ^min < <vcom> ^max >= <vcom> ^com <hcmo> ^layer <lay>) + - (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <vcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min <vcom> ^max > <vcom> ^com <vmax> ^layer <> <lay>) + --> + (modify <h> ^max <vcmo> ^max-net <nn1>) +) + +(p p69 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min <vcom> ^max { <hmax> > <vcom> } ^com <vmax> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min < <vmax> ^max >= <vmax> ^com <vcpo> ^layer <lay> ^compo <garb1> ^commo <vcom>) + (horizontal ^net-name nil ^min <= <vcom> ^max > <vcom> ^com <hcmo> ^layer <lay>) + - (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <vcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <vcom> ^max <vcom> ^com <vmax> ^layer <> <lay>) + --> + (modify <h> ^min <vcpo> ^min-net <nn1>) +) + +(p p70 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max <vcom> ^com <vmin> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min <= <vmin> ^max > <vmin> ^com <vcmo> ^layer <lay> ^compo <vcom> ^commo <garb1>) + (horizontal ^net-name nil ^min < <vcom> ^max >= <vcom> ^com <hcpo> ^layer <lay>) + - (vertical ^net-name nil ^min < <vmin> ^max <vmin> ^com <vcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min <vcom> ^max > <vcom> ^com <vmin> ^layer <> <lay>) + --> + (modify <h> ^max <vcmo> ^max-net <nn1>) +) + +(p p71 + (context ^present propagate-constraint) + { <v> (vertical ^net-name nil ^min <vmin> ^max <vmax> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + { <h> (horizontal ^net-name nil ^min <vcom> ^max { <hmax> > <vcom> } ^com <vmin> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + (vertical ^net-name { <nn1> <> nil } ^min <= <vmin> ^max > <vmin> ^com <vcpo> ^layer <lay> ^compo <garb1> ^commo <vcom>) + (horizontal ^net-name nil ^min <= <vcom> ^max > <vcom> ^com <hcpo> ^layer <lay>) + - (vertical ^net-name nil ^min < <vmin> ^max <vmin> ^com <vcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min < <vcom> ^max <vcom> ^com <vmin> ^layer <> <lay>) + --> + (modify <h> ^min <vcpo> ^min-net <nn1>) +) + +(p p72 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min <hcom> ^max { <vmax> > <hcom> } ^com <hmax> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min < <hmax> ^max >= <hmax> ^com <hcpo> ^layer <lay> ^compo <garb1> ^commo <hcom>) + (vertical ^net-name nil ^min <= <hcom> ^max > <hcom> ^com <vcmo> ^layer <lay>) + - (horizontal ^net-name nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com <hmax> ^layer <> <lay>) + --> + (modify <v> ^min <hcpo> ^min-net <nn1>) +) + +(p p73 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min { <vmin> < <hcom> } ^max <hcom> ^com <hmax> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min < <hmax> ^max >= <hmax> ^com <hcmo> ^layer <lay> ^compo <hcom> ^commo <garb1>) + (vertical ^net-name nil ^min < <hcom> ^max >= <hcom> ^com <vcmo> ^layer <lay>) + - (horizontal ^net-name nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com <hmax> ^layer <> <lay>) + --> + (modify <v> ^max <hcmo> ^max-net <nn1>) +) + +(p p74 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min <hcom> ^max { <vmax> > <hcom> } ^com <hmin> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min <= <hmin> ^max > <hmin> ^com <hcpo> ^layer <lay> ^compo <garb1> ^commo <hcom>) + (vertical ^net-name nil ^min <= <hcom> ^max > <hcom> ^com <vcpo> ^layer <lay>) + - (horizontal ^net-name nil ^min < <hmin> ^max <hmin> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name nil ^min < <hcom> ^max <hcom> ^com <hmin> ^layer <> <lay>) + --> + (modify <v> ^min <hcpo> ^min-net <nn1>) +) + +(p p75 + (context ^present propagate-constraint) + { <h> (horizontal ^net-name nil ^min <hmin> ^max <hmax> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo>) } + { <v> (vertical ^net-name nil ^min { <vmin> < <hcom> } ^max <hcom> ^com <hmin> ^layer <lay> ^compo <vcpo> ^commo <vcmo>) } + (horizontal ^net-name { <nn1> <> nil } ^min <= <hmin> ^max > <hmin> ^com <hcmo> ^layer <lay> ^compo <hcom> ^commo <garb1>) + (vertical ^net-name nil ^min < <hcom> ^max >= <hcom> ^com <vcpo> ^layer <lay>) + - (horizontal ^net-name nil ^min < <hmin> ^max <hmin> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name nil ^min <hcom> ^max > <hcom> ^com <hmin> ^layer <> <lay>) + --> + (modify <v> ^max <hcmo> ^max-net <nn1>) +) + +(p p76 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay>) + (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <vcom> ^layer <vlay>) + (horizontal ^net-name { <nn2> <> <nn1> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer { <hlay> <> <vlay> } ^compo <hcpo> ^commo <vmax>) + - (horizontal ^status nil ^min <= <vcom> ^max >= <vcom> ^com <vmax>) + { <v> (vertical ^net-name nil ^min <vmax> ^max > <vmax> ^com <vcom> ^layer <hlay>) } + --> + (modify <v> ^min <hcom> ^min-net <nn2>) +) + +(p p77 + (context ^present propagate-constraint) + (vertical ^net-name { <nn1> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay>) + (vertical ^net-name nil ^min <garb1> ^max { <vmin> > <garb1> } ^com <vcom> ^layer <vlay>) + (horizontal ^net-name { <nn2> <> <nn1> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer { <hlay> <> <vlay> } ^compo <vmin> ^commo <hcmo>) + - (horizontal ^status nil ^min <= <vcom> ^max >= <vcom> ^com <vmin>) + { <v> (vertical ^net-name nil ^min <garb2> ^max { <vmin> > <garb2> } ^com <vcom> ^layer <hlay>) } + --> + (modify <v> ^max <hcom> ^max-net <nn2>) +) + +(p p78 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay>) + (horizontal ^net-name nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <hlay>) + (vertical ^net-name { <nn2> <> <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer { <vlay> <> <hlay> } ^compo <vcpo> ^commo <hmax>) + - (vertical ^status nil ^min <= <hcom> ^max >= <hcom> ^com <hmax>) + { <h> (horizontal ^net-name nil ^min <hmax> ^max > <hmax> ^com <hcom> ^layer <vlay>) } + --> + (modify <h> ^min <vcom> ^min-net <nn2>) +) + +(p p79 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn1> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay>) + (horizontal ^net-name nil ^min <garb1> ^max { <hmin> > <garb1> } ^com <hcom> ^layer <hlay>) + (vertical ^net-name { <nn2> <> <nn1> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer { <vlay> <> <hlay> } ^compo <hmin> ^commo <vcmo>) + - (vertical ^status nil ^min <= <hcom> ^max >= <hcom> ^com <hmin>) + { <h> (horizontal ^net-name nil ^min <garb2> ^max { <hmin> > <garb2> } ^com <hcom> ^layer <vlay>) } + --> + (modify <h> ^max <vcom> ^max-net <nn2>) +) + +(p p80 + (context ^present propagate-constraint) + (last-col <lc>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> <= 1 } ^max <vmax> ^com <vcom> ^layer <vlay> ^pin-name <pn> ^commo <vcmo>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <vcom> ^max { <hmax> >= <lc> } ^com <vmax> ^layer <hlay>) + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max <vcom> ^com { <hcom> >= <vmin> <= <vmax> } ^layer <lay>) } + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com { > <hcom> <= <vmax> }) + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com { < <hcom> >= <vmin> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com { > <hcom> <= <vmax> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com { < <hcom> >= <vmin> }) + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com <hcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name <nn> ^min <= <vmax> ^max >= <vmax> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name nil ^min <= <vmax> ^max >= <vmax> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name nil ^min <= <vmax> ^max >= <vmax> ^com <vcom>) + - (vertical ^net-name <nn> ^min <vmax> ^max > <vmax> ^com <vcom>) + - (vertical ^net-name nil ^min <= <vmin> ^max >= <vmin> ^com <vcom>) + - (vertical ^net-name <nn> ^min < <vmin> ^max <vmin> ^com <vcom>) + --> + (make (substr <h> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <vcmo>) + (modify <h> ^max <vcmo> ^max-net <nn>) + (make ff ^grid-x <vcmo> ^grid-y <hcom> ^grid-layer <lay> ^net-name <nn> ^pin-name <pn> ^came-from east) +) + +(p p81 + (context ^present propagate-constraint) + (last-row <lr>) + (last-col <lc>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max { <vmax> >= <lr> } ^com <vcom> ^layer <vlay> ^pin-name <pn> ^commo <vcmo>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <vcom> ^max { <hmax> >= <lc> } ^com <vmin> ^layer <hlay>) + { <h> (horizontal ^net-name nil ^min { <hmin> < <vcom> } ^max <vcom> ^com { <hcom> >= <vmin> <= <vmax> } ^layer <lay>) } + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com { > <hcom> <= <vmax> }) + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com { < <hcom> >= <vmin> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com { > <hcom> <= <vmax> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com { < <hcom> >= <vmin> }) + - (horizontal ^net-name <nn> ^min < <vcom> ^max >= <vcom> ^com <hcom> ^layer <> <lay>) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <> <lay>) + - (vertical ^net-name <nn> ^min <= <vmin> ^max >= <vmin> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name nil ^min <= <vmin> ^max >= <vmin> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name nil ^min <= <vmin> ^max >= <vmin> ^com <vcom>) + - (vertical ^net-name <nn> ^min < <vmin> ^max <vmin> ^com <vcom>) + - (vertical ^net-name nil ^min <= <vmax> ^max >= <vmax> ^com <vcom>) + - (vertical ^net-name <nn> ^min <vmax> ^max > <vmax> ^com <vcom>) + --> + (make (substr <h> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <vcmo>) + (modify <h> ^max <vcmo> ^max-net <nn>) + (make ff ^grid-x <vcmo> ^grid-y <hcom> ^grid-layer <lay> ^net-name <nn> ^pin-name <pn> ^came-from east) +) + +(p p82 + (context ^present propagate-constraint) + (horizontal ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay> ^pin-name <pn> ^commo <hcmo>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <hcom> ^max <vmax1> ^com <hmin> ^layer <vlay1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <hcom> ^max <vmax2> ^com <hmax> ^layer <vlay2>) + { <v> (vertical ^net-name nil ^min { <vmin> < <hcom> } ^max <hcom> ^com { <vcom> >= <hmin> <= <hmax> } ^layer <lay>) } + - (vertical ^net-name <nn> ^min < <hcom> ^max >= <hcom> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name <nn> ^min < <hcom> ^max >= <hcom> ^com { < <vcom> >= <hmin> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <hcom> ^com { > <vcom> <= <hmax> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <hcom> ^com { < <vcom> >= <hmin> }) + - (vertical ^net-name <nn> ^min < <hcom> ^max >= <hcom> ^com <vcom> ^layer <> <lay>) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <> <lay>) + - (horizontal ^net-name <nn> ^min <= <hmax> ^max >= <hmax> ^com { > <hcom> <= <vmax2> }) + - (horizontal ^net-name <nn> ^min <= <hmin> ^max >= <hmin> ^com { > <hcom> <= <vmax1> }) + - (horizontal ^net-name nil ^min <= <hmax> ^max >= <hmax> ^com { > <hcom> <= <vmax2> }) + - (horizontal ^net-name nil ^min <= <hmin> ^max >= <hmin> ^com { > <hcom> <= <vmax1> }) + - (horizontal ^net-name nil ^min <= <hmax> ^max >= <hmax> ^com <hcom>) + - (horizontal ^net-name <nn> ^min <hmax> ^max > <hmax> ^com <hcom>) + - (horizontal ^net-name nil ^min <= <hmin> ^max >= <hmin> ^com <hcom>) + - (horizontal ^net-name <nn> ^min < <hmin> ^max <hmin> ^com <hcom>) + --> + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <hcmo>) + (modify <v> ^max <hcmo> ^max-net <nn>) + (make ff ^grid-x <vcom> ^grid-y <hcmo> ^grid-layer <lay> ^net-name <nn> ^pin-name <pn> ^came-from north) +) + +(p p377 + (context ^present find-no-of-pins-on-a-row-col) + (horizontal ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gy> ^layer <lay> ^compo <egarb1> ^commo <egabr2>) + (ff ^net-name <nn> ^grid-x { <fx> >= <min> <= <max> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn1>) + (ff ^net-name <nn> ^grid-y <gy> ^pin-name { <pn2> <> <pn1> } ^grid-x { <gx> > <fx> <= <max> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <fx> ^max >= <gx> ^com <gy>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { >= <fx> <= <gx> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <fx> ^max >= <fx> ^com <gy> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col row ^coor <gy>) + --> + (make total ^net-name <nn> ^row-col row ^coor <gy> ^level-pins 1 ^total-pins <np> ^min-xy <fx> ^max-xy <gx> ^last-pin <pn1> ^last-xy <fx>) +) + +(p p378 + (context ^present find-no-of-pins-on-a-row-col) + (horizontal ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gy> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (ff ^net-name <nn> ^grid-x { <fx> >= <min> <= <max> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx> > <fx> <= <max> } ^pin-name { <pn2> <> <pn1> }) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^pin-name <> <pn1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <fx> ^max >= <gx> ^com <gy>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { >= <fx> <= <gx> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <fx> ^max >= <fx> ^com <gy> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col row ^coor <gy>) + --> + (make total ^net-name <nn> ^row-col row ^coor <gy> ^level-pins 1 ^total-pins <np> ^min-xy <fx> ^max-xy <gx> ^last-pin <pn1> ^last-xy <fx>) +) + +(p p379 + (context ^present find-no-of-pins-on-a-row-col) + (horizontal ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gy> ^layer <lay>) + (ff ^net-name <nn> ^grid-x { <fx> >= <min> <= <max> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx> < <fx> >= <min> } ^pin-name { <pn2> <> <pn1> }) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^pin-name <> <pn1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <fx> ^com <gy>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <= <fx> >= <gx> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <fx> ^max >= <fx> ^com <gy> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col row ^coor <gy>) + --> + (make total ^net-name <nn> ^row-col row ^coor <gy> ^level-pins 1 ^total-pins <np> ^min-xy <gx> ^max-xy <fx> ^last-pin <pn2> ^last-xy <gx>) +) + +(p p380 + (context ^present find-no-of-pins-on-a-row-col) + (vertical ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gx> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <fy> >= <min> <= <max> } ^grid-layer <garb1> ^pin-name <pn1>) + (ff ^net-name <nn> ^grid-x <gx> ^pin-name { <pn2> <> <pn1> } ^grid-y { <gy> > <fy> <= <max> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <fy> ^max >= <gy> ^com <gx>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <fy> <= <gy> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <fy> ^max >= <fy> ^com <gx> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col col ^coor <gx>) + --> + (make total ^net-name <nn> ^row-col col ^coor <gx> ^level-pins 1 ^total-pins <np> ^min-xy <fy> ^max-xy <gy> ^last-pin <pn1> ^last-xy <fy>) +) + +(p p381 + (context ^present find-no-of-pins-on-a-row-col) + (vertical ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gx> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <fy> >= <min> <= <max> } ^grid-layer <garb1> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy> > <fy> <= <max> } ^pin-name { <pn2> <> <pn1> }) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^pin-name <> <pn1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <fy> ^max >= <gy> ^com <gx>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <fy> <= <gy> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <fy> ^max >= <fy> ^com <gx> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col col ^coor <gx>) + --> + (make total ^net-name <nn> ^row-col col ^coor <gx> ^level-pins 1 ^total-pins <np> ^min-xy <fy> ^max-xy <gy> ^last-pin <pn1> ^last-xy <fy>) +) + +(p p382 + (context ^present find-no-of-pins-on-a-row-col) + (vertical ^net-name nil ^min <min> ^max { <max> > <min> } ^com <gx> ^layer <lay> ^compo <egarb1> ^commo <egarb2>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <fy> >= <min> <= <max> } ^grid-layer <garb1> ^pin-name <pn1>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy> < <fy> >= <min> } ^pin-name { <pn2> <> <pn1> }) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^pin-name <> <pn1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <fy> ^com <gx>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <gy> <= <fy> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <fy> ^max >= <fy> ^com <gx> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + (net ^net-name <nn> ^net-no-of-pins <np>) + - (total ^net-name <nn> ^row-col col ^coor <gx>) + --> + (make total ^net-name <nn> ^row-col col ^coor <gx> ^level-pins 1 ^total-pins <np> ^min-xy <gy> ^max-xy <fy> ^last-pin <pn2> ^last-xy <gy>) +) + +(p p383 + (context ^present find-no-of-pins-on-a-row-col) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <gy> ^grid-layer <garb2> ^pin-name <pn>) + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <np> ^no-of-bottom-pins <garb3>) + - (ff ^net-name <nn> ^grid-y <= <gy> ^pin-name <> <pn>) + - (total ^net-name <nn>) + --> + (make total ^net-name <nn> ^row-col row ^coor <gy> ^level-pins <np> ^total-pins <np>) +) + +(p p384 + (context ^present find-no-of-pins-on-a-row-col) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <gy> ^grid-layer <garb2> ^pin-name <pn>) + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <garb3> ^no-of-bottom-pins <np>) + - (ff ^net-name <nn> ^grid-y >= <gy> ^pin-name <> <pn>) + - (total ^net-name <nn>) + --> + (make total ^net-name <nn> ^row-col row ^coor <gy> ^level-pins <np> ^total-pins <np>) +) + +(p p385 + (context ^present find-no-of-pins-on-a-row-col) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <np> ^no-of-bottom-pins <garb2>) + - (total ^net-name <nn>) + (ff ^net-name <nn> ^grid-y <gy> ^pin-name <> <pn> ^grid-x { <fx> > <gx> }) + - (ff ^net-name <nn> ^grid-y < <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <fx> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <fx> ^com <gy>) + { <v1> (vertical ^net-name nil ^min { <min> < <gy> } ^max >= <gy> ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^min-net <mn>) } + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <gy> ^como <hcmo>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <hcmo> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify <v1> ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff1> ^grid-y <hcmo> ^can-chng-layer nil) + (make total ^net-name <nn> ^row-col row ^coor <hcmo> ^level-pins <np> ^total-pins <np>) +) + +(p p386 + (context ^present find-no-of-pins-on-a-row-col) + { <ff1> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <garb2> ^no-of-bottom-pins <np>) + - (total ^net-name <nn>) + (ff ^net-name <nn> ^grid-y <gy> ^pin-name <> <pn> ^grid-x { <fx> > <gx> }) + - (ff ^net-name <nn> ^grid-y > <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <fx> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <fx> ^com <gy>) + { <v1> (vertical ^net-name nil ^min <= <gy> ^max { <max> > <gy> } ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <mn>) } + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <hcmo> ^como <gy>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <max> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <nn> ^max-net <mn>) + (modify <v1> ^max <gy> ^max-net <nn>) + (make vertical ^net-name <nn> ^min <gy> ^max <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify <ff1> ^grid-y <hcmo> ^can-chng-layer nil) + (make total ^net-name <nn> ^row-col row ^coor <hcmo> ^level-pins <np> ^total-pins <np>) +) + +(p p387 + { <t1> (total ^net-name <nn> ^row-col row ^coor <y> ^level-pins <np> ^total-pins <np> ^min-xy nil ^max-xy nil) } + (pin ^net-name <nn> ^pin-x <px1>) + - (pin ^net-name <nn> ^pin-x < <px1>) + (pin ^net-name <nn> ^pin-x { <px2> > <px1> }) + - (pin ^net-name <nn> ^pin-x > <px2>) + --> + (modify <t1> ^min-xy <px1> ^max-xy <px2>) +) + +(p p388 + (context ^present find-no-of-pins-on-a-row-col) + --> + (make context ^previous find-no-of-pins-on-a-row-col) + (remove 1) +) + +(p p389 + (context ^previous find-no-of-pins-on-a-row-col) + (total) + --> + (remove 1) + (make context ^present modify-total) +) + +(p p390 + (context ^present delete-totals) + --> + (modify 1 ^present choose-between-nets-on-the-same-row-col) +) + +(p p391 + { <c1> (context ^present << choose-between-nets-on-the-same-row-col choose-between-nets-on-the-same-row-col-con >>) } + { <t1> (total ^net-name <nn> ^row-col { << row col >> <rc> } ^coor <xy> ^level-pins <cou> ^total-pins <garb1>) } + - (total ^net-name <> <nn> ^level-pins >= <cou>) + - (total ^net-name <nn> ^row-col <> <rc> ^level-pins >= <cou>) + --> + (remove <c1> <t1>) + (make change-priority) + (make tran-total <rc> <xy> (substr <t1> nets inf)) +) + +(p p392 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <garb1> ^row-col { << row col >> <garb2> } ^coor <garb3> ^level-pins <cou> ^total-pins <cou>) + { <t1> (total ^level-pins < <cou>) } + --> + (remove <t1>) +) + +(p p393 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <garb1> ^row-col { << row col >> <garb2> } ^coor <garb3> ^level-pins <cou> ^total-pins <garb4>) + { <t1> (total ^level-pins <cou1> ^total-pins { < <cou> <> <cou1> }) } + --> + (remove <t1>) +) + +(p p394 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn> ^row-col { << row col >> <rc> } ^coor <garb1> ^level-pins <cou>) + { <t1> (total ^net-name <nn> ^row-col <> <rc> ^level-pins <cou>) } + --> + (remove <t1>) +) + +(p p395 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn> ^row-col { << row col >> <rc> } ^coor <xy> ^level-pins <cou> ^total-pins <garb1>) + { <t1> (total ^net-name <nn> ^row-col <rc> ^coor <> <xy> ^level-pins <cou>) } + --> + (remove <t1>) +) + +(p p396 + { <c1> (context ^present << choose-between-nets-on-the-same-row-col choose-between-nets-on-the-same-row-col-con >>) } + { <t1> (total ^net-name <nn> ^row-col { << row col >> <rc> } ^coor <xy> ^level-pins <cou> ^total-pins <cou>) } + - (total ^net-name <> <nn> ^level-pins <cou> ^total-pins <cou>) + --> + (remove <c1> <t1>) + (make change-priority) + (make tran-total <rc> <xy> (substr <t1> nets inf)) +) + +(p p397 + { <t1> (tran-total <rc> <xy> { <nn> <> nil <> end } <min> <max>) } + --> + (write (crlf) |***** next net to be routed is| <nn> *****) + (make next-segment <nn> <rc> <xy> useless <min> <max>) + (remove <t1>) + (make tran-total <rc> <xy> (substr <t1> 7 inf)) +) + +(p p398 + { <t1> (tran-total <rc> <xy> nil) } + --> + (make dominant-layer) + (remove <t1>) + (make goal cleanup total-verti) + (make goal cleanup counted-verti) + (make goal cleanup total) + (make goal cleanup extend-ff-tried) +) + +(p p399 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn> ^row-col { << row col >> <garb1> } ^coor <garb2> ^level-pins <cou> ^total-pins <cou>) + { <t1> (total ^net-name <> <nn> ^level-pins <cou> ^total-pins > <cou>) } + --> + (remove <t1>) +) + +(p p400 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn> ^row-col { << row col >> <garb1> } ^coor <garb2> ^level-pins <cou> ^total-pins <cou1>) + { <t1> (total ^net-name <> <nn> ^level-pins <cou> ^total-pins > <cou1>) } + - (total ^net-name <garb3> ^row-col <garb4> ^coor <garb5> ^level-pins <cou2> ^total-pins <cou2>) + --> + (remove <t1>) +) + +(p p401 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <garb1> ^row-col <garb2> ^coor <garb3> ^level-pins <cou1> ^total-pins <cou2>) + { <t1> (total ^net-name <garb4> ^row-col <garb5> ^coor <garb6> ^level-pins < <cou1> ^total-pins < <cou2>) } + --> + (remove <t1>) +) + +(p p402 + (context ^present choose-between-nets-on-the-same-row-col) + --> + (modify 1 ^present choose-between-nets-on-the-same-row-col-con) +) + +(p p403 + (context ^present choose-between-nets-on-the-same-row-col-con) + { <t1> (total ^net-name <nn> ^row-col row ^level-pins <cou> ^total-pins <cou2> ^cong nil) } + (total ^net-name <> <nn> ^level-pins <cou> ^total-pins <cou2>) + (pin ^net-name <nn> ^pin-x <px1>) + - (pin ^net-name <nn> ^pin-x < <px1>) + (pin ^net-name <nn> ^pin-x { <px2> > <px1> }) + - (pin ^net-name <nn> ^pin-x > <px2>) + (congestion ^direction col ^coordinate { >= <px1> <= <px2> } ^no-of-nets <non>) + - (congestion ^direction col ^coordinate { >= <px1> <= <px2> } ^no-of-nets > <non>) + --> + (modify <t1> ^cong <non>) +) + +(p p404 + (context ^present choose-between-nets-on-the-same-row-col-con) + { <t1> (total ^net-name <nn> ^row-col col ^level-pins <cou> ^total-pins <cou2> ^cong nil) } + (total <> <nn> { } { } <cou> <cou2>) + (pin ^net-name <nn> ^pin-y <py1>) + - (pin ^net-name <nn> ^pin-y < <py1>) + (pin ^net-name <nn> ^pin-y { <py2> > <py1> }) + - (pin ^net-name <nn> ^pin-y > <py2>) + (congestion ^direction row ^coordinate { >= <py1> <= <py2> } ^no-of-nets <non>) + - (congestion ^direction row ^coordinate { >= <py1> <= <py2> } ^no-of-nets > <non>) + --> + (modify <t1> ^cong <non>) +) + +(p p405 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil } ^min-xy <min1> ^max-xy <max1>) + (total ^net-name <> <nn> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil } ^min-xy { <min2> > <max1> } ^max-xy <max2>) + { <t> (total ^net-name <nn1> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil } ^min-xy <= <max1> ^max-xy >= <min2>) } + --> + (remove <t>) +) + +(p p406 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil } ^min-xy <min1> ^max-xy <max1>) + { <t> (total ^net-name <> <nn> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil } ^min-xy >= <min1> ^max-xy <= <max1>) } + --> + (remove <t>) +) + +(p p407 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) + { <t> (total ^net-name { <nn1> <> <nn> } ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) } + (<< vertical-cycle horizontal-cycle >> <nn1>) + --> + (remove <t>) +) + +(p p408 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^row-col row ^coor <y> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) + { <t> (total ^net-name { <nn1> <> <nn> } ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) } + (pin ^net-name <nn1> ^pin-y { <py> < <y> } ^pin-channel-side << left right >>) + - (pin ^net-name <nn> ^pin-y { > <py> < <y> } ^pin-channel-side << left right >>) + --> + (remove <t>) +) + +(p p409 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^row-col row ^coor <y> ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) + { <t> (total ^net-name { <nn1> <> <nn> } ^level-pins <cou> ^total-pins <cou2> ^cong { <non> <> nil }) } + (pin ^net-name <nn1> ^pin-y { <py> > <y> } ^pin-channel-side << left right >>) + - (pin ^net-name <nn> ^pin-y { > <y> < <py> } ^pin-channel-side << left right >>) + --> + (remove <t>) +) + +(p p410 + (context ^present choose-between-nets-on-the-same-row-col-con) + (total ^net-name <nn> ^level-pins <cou> ^total-pins <cou2> ^cong <non>) + - (total ^cong nil) + { <t> (total ^net-name <> <nn> ^level-pins <cou> ^total-pins <cou2> ^cong <= <non>) } + --> + (remove <t>) +) + +(p p411 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn1> ^row-col <rc1> ^coor <xy1> ^level-pins <cou> ^total-pins > <cou>) + { <t1> (total ^net-name <nn2> ^row-col { <rc2> <> <rc1> } ^coor <xy2> ^level-pins <cou> ^total-pins > <cou>) } + { <t2> (total ^net-name <> <nn2> ^row-col <rc2> ^coor <xy2> ^level-pins <cou> ^total-pins > <cou>) } + --> + (remove <t1> <t2>) +) + +(p p412 + (context ^present choose-between-nets-on-the-same-row-col) + (total ^net-name <nn1> ^row-col <rc1> ^coor <xy1> ^level-pins <cou> ^total-pins > <cou>) + { <t1> (total ^net-name <nn2> ^row-col <rc2> ^coor { <xy2> <> <xy1> } ^level-pins <cou> ^total-pins > <cou>) } + { <t2> (total ^net-name <> <nn2> ^row-col <rc2> ^coor <xy2> ^level-pins <cou> ^total-pins > <cou>) } + --> + (remove <t1> <t2>) +) + +(p p413 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-bottom-pins { <np> > 1 } ^net-is-routed <> yes) + - (total-verti <nn> bottom) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side bottom) + --> + (make total-verti <nn> bottom 0 <np>) +) + +(p p414 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-bottom-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> bottom) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side bottom) + (constraint ^constraint-type << horizontal vertical >> ^net-name-1 <nn>) + --> + (make total-verti <nn> bottom 0 <np>) +) + +(p p415 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-bottom-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> bottom) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side bottom) + (constraint ^constraint-type << horizontal vertical >> ^net-name-2 <nn>) + --> + (make total-verti <nn> bottom 0 <np>) +) + +(p p416 + (context ^present find-no-of-vcg-hcg) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <garb1>) + (pin ^net-name <nn> ^pin-x <gx> ^pin-channel-side top ^pin-name <pn1>) + (net ^net-name { <nn1> <> <nn> } ^no-of-bottom-pins { <np> > 0 } ^net-is-routed <> yes) + (pin ^net-name <nn1> ^pin-x <gx> ^pin-channel-side bottom ^pin-name <pn2>) + - (total-verti <nn1> bottom) + - (constraint ^constraint-type vertical ^net-name-1 <nn> ^net-name-2 <nn1> ^pin-name-1 <pn1> ^pin-name-2 <pn2>) + --> + (make counted-verti <nn1> bottom <nn> <pn1> <pn2>) + (make total-verti <nn1> bottom 1 <np>) +) + +(p p417 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-left-pins { <np> > 1 } ^net-is-routed <> yes) + - (total-verti <nn> left) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side left) + --> + (make total-verti <nn> left 0 <np>) +) + +(p p418 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-left-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> left) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side left) + (constraint ^constraint-type << horizontal vertical >> ^net-name-1 <nn>) + --> + (make total-verti <nn> left 0 <np>) +) + +(p p419 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-left-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> left) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side left) + (constraint ^constraint-type << horizontal vertical >> ^net-name-2 <nn>) + --> + (make total-verti <nn> left 0 <np>) +) + +(p p420 + (context ^present find-no-of-vcg-hcg) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <gy> ^grid-layer <garb3> ^pin-name <garb2>) + (pin ^net-name <nn> ^pin-y <gy> ^pin-channel-side right ^pin-name <pn1>) + (net ^net-name { <nn1> <> <nn> } ^no-of-left-pins { <np> > 0 } ^net-is-routed <> yes) + (pin ^net-name <nn1> ^pin-y <gy> ^pin-channel-side left ^pin-name <pn2>) + - (total-verti <nn1> left) + - (constraint ^constraint-type horizontal ^net-name-1 <nn> ^net-name-2 <nn1> ^pin-name-1 <pn1> ^pin-name-2 <pn2>) + --> + (make counted-verti <nn1> left <nn> <pn1> <pn2>) + (make total-verti <nn1> left 1 <np>) +) + +(p p421 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-top-pins { <np> > 1 } ^net-is-routed <> yes) + - (total-verti <nn> top) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side top) + --> + (make total-verti <nn> top 0 <np>) +) + +(p p422 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-top-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> top) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side top) + (constraint ^constraint-type << horizontal vertical >> ^net-name-1 <nn>) + --> + (make total-verti <nn> top 0 <np>) +) + +(p p423 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-top-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> top) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side top) + (constraint ^constraint-type << horizontal vertical >> ^net-name-2 <nn>) + --> + (make total-verti <nn> top 0 <np>) +) + +(p p424 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-right-pins { <np> > 1 } ^net-is-routed <> yes) + - (total-verti <nn> right) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side right) + --> + (make total-verti <nn> right 0 <np>) +) + +(p p425 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-right-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> right) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side right) + (constraint ^constraint-type << horizontal vertical >> ^net-name-1 <nn>) + --> + (make total-verti <nn> right 0 <np>) +) + +(p p426 + (context ^present find-no-of-vcg-hcg) + (net ^net-name <nn> ^no-of-right-pins { <np> > 0 } ^net-is-routed <> yes) + - (total-verti <nn> right) + (ff ^net-name <nn> ^grid-x <garb1> ^grid-y <garb2> ^grid-layer <garb3> ^pin-name <pn>) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side right) + (constraint ^constraint-type << horizontal vertical >> ^net-name-2 <nn>) + --> + (make total-verti <nn> right 0 <np>) +) + +(p p427 + (context ^present find-no-of-vcg-hcg) + (total-verti <nn> bottom <ntc>) + (constraint ^constraint-type vertical ^net-name-1 <tn> ^net-name-2 <nn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + - (counted-verti <nn> bottom <tn> <tpn> <bpn>) + --> + (make counted-verti <nn> bottom <tn> <tpn> <bpn>) + (modify 2 ^4 (compute <ntc> + 1)) +) + +(p p428 + (context ^present find-no-of-vcg-hcg) + (total-verti <nn> left <ntc>) + (constraint ^constraint-type horizontal ^net-name-1 <tn> ^net-name-2 <nn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + - (counted-verti <nn> left <tn> <tpn> <bpn>) + --> + (make counted-verti <nn> left <tn> <tpn> <bpn>) + (modify 2 ^4 (compute <ntc> + 1)) +) + +(p p429 + (context ^present find-no-of-vcg-hcg) + (total-verti <nn> top <ntc>) + (constraint ^constraint-type vertical ^net-name-1 <nn> ^net-name-2 <bn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + - (counted-verti <nn> top <bn> <tpn> <bpn>) + --> + (make counted-verti <nn> top <bn> <tpn> <bpn>) + (modify 2 ^4 (compute <ntc> + 1)) +) + +(p p430 + (context ^present find-no-of-vcg-hcg) + (total-verti <nn> right <ntc>) + (constraint ^constraint-type horizontal ^net-name-1 <nn> ^net-name-2 <bn> ^pin-name-1 <tpn> ^pin-name-2 <bpn>) + - (counted-verti <nn> right <bn> <tpn> <bpn>) + --> + (make counted-verti <nn> right <bn> <tpn> <bpn>) + (modify 2 ^4 (compute <ntc> + 1)) +) + +(p p431 + (context ^present find-no-of-vcg-hcg) + --> + (remove 1) + (make context ^previous find-no-of-vcg-hcg) +) + +(p p432 + (context ^previous find-no-of-vcg-hcg) + (total-verti) + --> + (remove 1) + (make context ^present choose-between-total-verti) + (make context ^present choose-between-total-verti-0) +) + +(p p433 + (context ^present choose-between-total-verti) + - (total-verti ^4 0) + { <t> (total-verti <nn> bottom <garb> > 1) } + - (ff ^net-name <nn> ^came-from south) + --> + (remove <t>) +) + +(p p434 + (context ^present choose-between-total-verti) + - (total-verti ^4 0) + { <t> (total-verti <nn> top <garb> > 1) } + - (ff ^net-name <nn> ^came-from north) + --> + (remove <t>) +) + +(p p435 + (context ^present choose-between-total-verti) + - (total-verti ^4 0) + { <t> (total-verti <nn> left <garb> > 1) } + - (ff ^net-name <nn> ^came-from west) + --> + (remove <t>) +) + +(p p436 + (context ^present choose-between-total-verti) + - (total-verti ^4 0) + { <t> (total-verti <nn> right <garb> > 1) } + - (ff ^net-name <nn> ^came-from east) + --> + (remove <t>) +) + +(p p437 + (context ^present choose-between-total-verti) + --> + (modify 1 ^present extend-total-verti) +) + +(p p438 + (context ^present choose-between-total-verti) + (total-verti ^4 > 0) + (total-verti ^4 0) + --> + (remove 3) +) + +(p p439 + (context ^present choose-between-total-verti) + (total-verti <nn> { << top bottom >> <tb> } > 0) + (total-verti <nn> { << top bottom >> <> <tb> } 0) + --> + (remove 3) +) + +(p p440 + (context ^present choose-between-total-verti) + (total-verti <nn> { << left right >> <tb> } > 0) + (total-verti <nn> { << left right >> <> <tb> } 0) + --> + (remove 3) +) + +(p p441 + (context ^present choose-between-total-verti-0) + (total-verti <nn> { << top bottom >> <tb> } > 0) + (total-verti <nn> { << top bottom >> <> <tb> } > 0) + --> + (remove 2 3) +) + +(p p442 + (context ^present choose-between-total-verti-0) + (total-verti <nn> { << left right >> <tb> } > 0) + (total-verti <nn> { << left right >> <> <tb> } > 0) + --> + (remove 2 3) +) + +(p p443 + (context ^present choose-between-total-verti-0) + --> + (remove 1) +) + +(p p444 + (context ^present extend-total-verti) + (total-verti <nn> bottom ^5 > 1) + - (total-verti ^5 1) + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) + - (ff ^net-name <nn> ^grid-y < <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy> ^com <gx>) + (vertical ^net-name nil ^min { <min> <= <gy> } ^max { > <min> > <gy> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + (congestion ^direction row ^coordinate <como> ^como <gy>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <como> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <como> ^max >= <como> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^min <min> ^max <gy> ^min-net <mn> ^max-net <nn> ^commo <vcmo> ^compo <vcpo> ^com <gx> ^layer <lay>) + (modify 4 ^min <como> ^min-net <nn>) + (make vertical ^net-name <nn> ^min <gy> ^max <como> ^layer <lay> ^commo <vcmo> ^compo <vcpo> ^pin-name <pn> ^com <gx>) + (modify 3 ^grid-y <como> ^can-chng-layer nil) + (remove 2) +) + +(p p445 + (context ^present extend-total-verti) + (total-verti <nn> left ^5 > 1) + - (total-verti ^5 1) + (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) + - (ff ^net-name <nn> ^grid-x < <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max > <gx> ^com <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx> } ^max { > <min> > <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + (congestion ^direction col ^coordinate <como> ^como <gx>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <como> ^max >= <como> ^com <gy> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <como> ^layer <lay>) + --> + (make horizontal ^net-name nil ^min <min> ^max <gx> ^min-net <mn> ^max-net <nn> ^commo <hcmo> ^compo <hcpo> ^com <gy> ^layer <lay>) + (modify 4 ^min <como> ^min-net <nn>) + (make horizontal ^net-name <nn> ^min <gx> ^max <como> ^layer <lay> ^commo <hcmo> ^compo <hcpo> ^pin-name <pn> ^com <gy>) + (modify 3 ^grid-x <como> ^can-chng-layer nil) + (remove 2) +) + +(p p446 + (context ^present extend-total-verti) + (total-verti <nn> top ^5 > 1) + - (total-verti ^5 1) + (ff ^came-from north ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) + - (ff ^net-name <nn> ^grid-y > <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy> ^com <gx>) + (vertical ^net-name nil ^max { <max> >= <gy> } ^min { < <max> < <gy> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^max-net <mn>) + (congestion ^direction row ^coordinate <gy> ^como <como>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <como> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <como> ^max >= <como> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^min <gy> ^max <max> ^max-net <mn> ^min-net <nn> ^commo <vcmo> ^compo <vcpo> ^com <gx> ^layer <lay>) + (modify 4 ^max <como> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <como> ^layer <lay> ^commo <vcmo> ^compo <vcpo> ^pin-name <pn> ^com <gx>) + (modify 3 ^grid-y <como> ^can-chng-layer nil) + (remove 2) +) + +(p p447 + (context ^present extend-total-verti) + (total-verti <nn> right ^5 > 1) + - (total-verti ^5 1) + (ff ^came-from east ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn>) + - (ff ^net-name <nn> ^grid-x > <gx>) + - (horizontal ^net-name { <nn> <> nil } ^min < <gx> ^max >= <gx> ^status nil ^com <gy>) + (horizontal ^net-name nil ^max { <max> >= <gx> } ^min { < <max> < <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^max-net <mn>) + (congestion ^direction col ^coordinate <gx> ^como <como>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <como> ^max >= <como> ^com <gy> ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <como> ^layer <lay>) + --> + (make horizontal ^net-name nil ^min <gx> ^max <max> ^max-net <mn> ^min-net <nn> ^commo <hcmo> ^compo <hcpo> ^com <gy> ^layer <lay>) + (modify 4 ^max <como> ^max-net <nn>) + (make horizontal ^net-name <nn> ^max <gx> ^min <como> ^layer <lay> ^commo <hcmo> ^compo <hcpo> ^pin-name <pn> ^com <gy>) + (modify 3 ^grid-x <como> ^can-chng-layer nil) + (remove 2) +) + +(p p448 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> bottom ^5 1) } + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> > <gy> } ^com { <vcom> < <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + - (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmin>) + { <c6> (vertical ^net-name nil ^min <vvmin> ^max { <vmin> > <vvmin> } ^com <vcom> ^layer <lay> ^compo <garb1> ^commo <garb2>) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { > <hmin> >= <gx> } ^com { <hcom> >= <vvmin> < <vmin> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com { >= <vvmin> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <vcom> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin> > <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c6> ^max <hcom> ^max-net <nn>) + (modify <c4> ^min <hcom>) + (make pull-ff north <nn> <gx> <gy> <gx> <hcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from north) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p449 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> bottom ^5 1) } + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> > <gy> } ^com { <vcom> < <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + { <c5> (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmin> ^grid-layer <garb1> ^pin-name <garb2>) } + { <c7> (vertical ^net-name nil ^min <vvmin> ^max { <vmin> > <vvmin> } ^com <vcom> ^layer <lay> ^compo <garb3> ^commo <garb4>) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { > <hmin> >= <gx> } ^com { <hcom> >= <vvmin> < <vmin> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com { >= <vvmin> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <vcom> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin> > <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c7> ^max <hcom> ^max-net <nn>) + (modify <c4> ^min <hcom>) + (make pull-ff north <nn> <gx> <gy> <gx> <hcom>) + (modify <c5> ^grid-y <hcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p450 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> bottom ^5 1) } + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> > <gy> } ^com { <vcom> < <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + { <c6> (vertical ^net-name nil ^min <vvmin> ^max { <vmin> > <vvmin> } ^com <vcom> ^layer <lay> ^compo <garb1> ^commo <garb2>) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { > <hmin> >= <gx> } ^com { <hcom> >= <vvmin> < <vmin> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com { >= <vvmin> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <vcom> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin> > <hcom> }) + { <c41> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin1> > <gy> } ^com { <vcom1> > <gx> } ^layer <lay> ^pin-name <pn1>) } + - (vertical-s ^net-name <> <nn> ^com <vcom1>) + { <c61> (vertical ^net-name nil ^min <vvmin1> ^max { <vmin1> > <vvmin1> } ^com <vcom1> ^layer <lay>) } + (horizontal ^net-name nil ^min { <hmin1> <= <gx> } ^max { > <hmin1> >= <vcom1> } ^com { <hcom1> >= <vvmin1> < <vmin1> <= <hcom> }) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom1> ^com { >= <vvmin1> < <hcom1> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <gx> < <vcom1> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin1> > <hcom1> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom1> ^max >= <vcom1> ^com <hcom1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom1> ^max >= <hcom1> ^com <vcom> ^layer <lay>) + --> + (modify <c61> ^max <hcom1> ^max-net <nn>) + (modify <c41> ^min <hcom1>) + (make pull-ff north <nn> <gx> <gy> <gx> <hcom1>) + (make ff ^net-name <nn> ^pin-name <pn1> ^grid-layer <lay> ^grid-x <vcom1> ^grid-y <hcom1> ^came-from north) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p451 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> bottom ^5 1) } + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> > <gy> } ^com { <vcom> > <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + - (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmin>) + { <c6> (vertical ^net-name nil ^min <vvmin> ^max { <vmin> > <vvmin> } ^com <vcom> ^layer <lay>) } + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom> } ^com { <hcom> >= <vvmin> < <vmin> }) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com { >= <vvmin> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <gx> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin> > <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c6> ^max <hcom> ^max-net <nn>) + (modify <c4> ^min <hcom>) + (make pull-ff north <nn> <gx> <gy> <gx> <hcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from north) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p452 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> bottom ^5 1) } + (ff ^came-from south ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min { <vmin> > <gy> } ^com { <vcom> > <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + { <c5> (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmin> ^grid-layer <garb1> ^pin-name <garb2>) } + { <c7> (vertical ^net-name nil ^min <vvmin> ^max { <vmin> > <vvmin> } ^com <vcom> ^layer <lay>) } + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom> } ^com { <hcom> >= <vvmin> < <vmin> }) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com { >= <vvmin> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <gx> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <vmin> > <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c7> ^max <hcom> ^max-net <nn>) + (modify <c4> ^min <hcom>) + (make pull-ff north <nn> <gx> <gy> <gx> <hcom>) + (modify <c5> ^grid-y <hcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p453 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> top ^5 1) } + (ff ^came-from north ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <vmax> < <gy> } ^com { <vcom> > <gx> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + - (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmax>) + { <c6> (vertical ^net-name nil ^min <vmax> ^max { <vvmax> > <vmax> } ^com <vcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom> } ^com { <hcom> <= <vvmax> > <vmax> }) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com { <= <vvmax> > <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <gx> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <vmax> < <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c6> ^min <hcom> ^min-net <nn>) + (modify <c4> ^max <hcom>) + (make pull-ff south <nn> <gx> <gy> <gx> <hcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from south) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p454 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> top ^5 1) } + (ff ^came-from north ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <vmax> < <gy> } ^com { <vcom> > <gx> } ^layer <lay> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + { <c5> (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmax> ^grid-layer <garb2> ^pin-name <garb3>) } + { <c7> (vertical ^net-name nil ^min <vmax> ^max { <vvmax> > <vmax> } ^com <vcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom> } ^com { <hcom> <= <vvmax> > <vmax> }) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com { <= <vvmax> > <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <gx> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <vmax> < <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c7> ^min <hcom> ^min-net <nn>) + (modify <c4> ^max <hcom>) + (make pull-ff south <nn> <gx> <gy> <gx> <hcom>) + (modify <c5> ^grid-y <hcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p455 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> top ^5 1) } + (ff ^came-from north ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <vmax> < <gy> } ^com { <vcom> < <gx> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + - (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmax>) + { <c6> (vertical ^net-name nil ^min <vmax> ^max { <vvmax> > <vmax> } ^com <vcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { > <hmin> >= <gx> } ^com { <hcom> <= <vvmax> > <vmax> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com { <= <vvmax> > <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <vcom> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <vmax> < <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c6> ^min <hcom> ^min-net <nn>) + (modify <c4> ^max <hcom>) + (make pull-ff south <nn> <gx> <gy> <gx> <hcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from south) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p456 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> top ^5 1) } + (ff ^came-from north ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <vmax> < <gy> } ^com { <vcom> < <gx> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (vertical-s ^net-name <> <nn> ^com <vcom>) + { <c5> (ff ^net-name <nn> ^grid-x <vcom> ^grid-y <vmax> ^grid-layer <garb4> ^pin-name <garb5>) } + { <c7> (vertical ^net-name nil ^min <vmax> ^max { <vvmax> > <vmax> } ^com <vcom> ^layer <lay> ^compo <garb6> ^commo <garb7>) } + (horizontal ^net-name nil ^min { <hmin> <= <vcom> } ^max { > <hmin> >= <gx> } ^com { <hcom> <= <vvmax> > <vmax> }) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com { <= <vvmax> > <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <vcom> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <vmax> < <hcom> }) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + --> + (modify <c7> ^min <hcom> ^min-net <nn>) + (modify <c4> ^max <hcom>) + (make pull-ff south <nn> <gx> <gy> <gx> <hcom>) + (modify <c5> ^grid-y <hcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p457 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> left ^5 1) } + (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <hmin> > <gx> } ^max <garb1> ^com { <hcom> < <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + - (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <hcom>) + { <c6> (horizontal ^net-name nil ^min <hhmin> ^max { <hmin> > <hhmin> } ^com <hcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (vertical ^net-name nil ^min { <vmin> <= <hcom> } ^max { > <vmin> >= <gy> } ^com { <vcom> >= <hhmin> < <hmin> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <gy> ^com { >= <hhmin> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { < <hmin> > <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c6> ^max <vcom> ^max-net <nn>) + (modify <c4> ^min <vcom>) + (make pull-ff east <nn> <gx> <gy> <gy> <vcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from east) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p458 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> left ^5 1) } + (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^net-name { <nn> <> nil } ^min { <hmin> > <gx> } ^max <garb1> ^com { <hcom> < <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + { <c5> (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <hcom> ^grid-layer <garb4> ^pin-name <garb5>) } + { <c7> (horizontal ^net-name nil ^min <hhmin> ^max { <hmin> > <hhmin> } ^com <hcom> ^layer <lay> ^compo <garb6> ^commo <garb7>) } + (vertical ^net-name nil ^min { <vmin> <= <hcom> } ^max { > <vmin> >= <gy> } ^com { <vcom> >= <hhmin> < <hmin> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <gy> ^com { >= <hhmin> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { < <hmin> > <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c7> ^max <vcom> ^max-net <nn>) + (modify <c4> ^min <vcom>) + (make pull-ff east <nn> <gx> <gy> <gy> <vcom>) + (modify <c5> ^grid-x <vcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p459 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> left ^5 1) } + (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^net-name { <nn> <> nil } ^min { <hmin> > <gx> } ^max <garb1> ^com { <hcom> > <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + - (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <hcom>) + { <c6> (horizontal ^net-name nil ^max <hmin> ^min { <hhmin> < <hmin> } ^com <hcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom> } ^com { <vcom> >= <hhmin> < <hmin> }) + - (vertical ^net-name nil ^min <= <gy> ^max >= <hcom> ^com { >= <hhmin> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <gy> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { < <hmin> > <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c6> ^max <vcom> ^max-net <nn>) + (modify <c4> ^min <vcom>) + (make pull-ff east <nn> <gx> <gy> <gy> <vcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from east) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p460 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> left ^5 1) } + (ff ^came-from west ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <hmin> > <gx> } ^max <garb1> ^com { <hcom> > <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + { <c5> (ff ^net-name <nn> ^grid-x <hmin> ^grid-y <hcom> ^grid-layer <garb4> ^pin-name <garb5>) } + { <c7> (horizontal ^net-name nil ^min <hhmin> ^max { <hmin> > <hhmin> } ^com <hcom> ^layer <lay> ^compo <garb6> ^commo <garb7>) } + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom> } ^com { <vcom> >= <hhmin> < <hmin> }) + - (vertical ^net-name nil ^min <= <gy> ^max >= <hcom> ^com { >= <hhmin> < <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <gy> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { < <hmin> > <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c7> ^max <vcom> ^max-net <nn>) + (modify <c4> ^min <vcom>) + (make pull-ff east <nn> <gx> <gy> <gy> <vcom>) + (modify <c5> ^grid-x <vcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p461 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> right ^5 1) } + (ff ^came-from east ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <hmax> < <gx> } ^com { <hcom> > <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + - (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <hcom>) + { <c6> (horizontal ^net-name nil ^min <hmax> ^max { <hhmax> > <hmax> } ^com <hcom> ^layer <lay> ^compo <garb4> ^commo <garb5>) } + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom> } ^com { <vcom> <= <hhmax> > <hmax> }) + - (vertical ^net-name nil ^min <= <gy> ^max >= <hcom> ^com { <= <hhmax> > <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <gy> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <hmax> < <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c6> ^min <vcom> ^min-net <nn>) + (modify <c4> ^max <vcom>) + (make pull-ff west <nn> <gx> <gy> <gy> <vcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from west) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p462 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> right ^5 1) } + (ff ^came-from east ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <hmax> < <gx> } ^com { <hcom> > <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + { <c5> (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <hcom> ^grid-layer <garb4> ^pin-name <garb5>) } + { <c7> (horizontal ^net-name nil ^min <hmax> ^max { <hhmax> > <hmax> } ^com <hcom> ^layer <lay> ^compo <gabr6> ^commo <garb7>) } + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom> } ^com { <vcom> <= <hhmax> > <hmax> }) + - (vertical ^net-name nil ^min <= <gy> ^max >= <hcom> ^com { <= <hhmax> > <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <gy> < <hcom> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <hmax> < <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c7> ^min <vcom> ^min-net <nn>) + (modify <c4> ^max <vcom>) + (make pull-ff west <nn> <gx> <gy> <gy> <vcom>) + (modify <c5> ^grid-x <vcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p463 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> right ^5 1) } + (ff ^came-from east ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <hmax> < <gx> } ^com { <hcom> < <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + - (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <hcom>) + { <c6> (horizontal ^net-name nil ^min <hmax> ^max { <hhmax> > <hmax> } ^com <hcom> ^layer <lay> ^compo <garb4> ^commo <gabr5>) } + (vertical ^net-name nil ^min { <vmin> <= <hcom> } ^max { > <vmin> >= <gy> } ^com { <vcom> <= <hhmax> > <hmax> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <gy> ^com { <= <hhmax> > <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <hmax> < <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c6> ^min <vcom> ^min-net <nn>) + (modify <c4> ^max <vcom>) + (make pull-ff west <nn> <gx> <gy> <gy> <vcom>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-layer <lay> ^grid-x <vcom> ^grid-y <hcom> ^came-from west) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p464 + (context ^present extend-total-verti) + { <c2> (total-verti <nn> right ^5 1) } + (ff ^came-from east ^net-name <nn> ^grid-x <gx> ^grid-y <gy>) + { <c4> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <hmax> < <gx> } ^com { <hcom> < <gy> } ^layer <lay> ^compo <garb2> ^commo <garb3> ^pin-name <pn>) } + - (horizontal-s ^net-name <> <nn> ^com <hcom>) + { <c5> (ff ^net-name <nn> ^grid-x <hmax> ^grid-y <hcom> ^grid-layer <garb4> ^pin-name <garb5>) } + { <c7> (horizontal ^net-name nil ^min <hmax> ^max { <hhmax> > <hmax> } ^com <hcom> ^layer <lay> ^compo <garb6> ^commo <garb7>) } + (vertical ^net-name nil ^min { <vmin> <= <hcom> } ^max { > <vmin> >= <gy> } ^com { <vcom> <= <hhmax> > <hmax> }) + - (vertical ^net-name nil ^min <= <hcom> ^max >= <gy> ^com { <= <hhmax> > <vcom> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { > <hmax> < <vcom> }) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <vcom> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom> ^max >= <vcom> ^com <hcom> ^layer <lay>) + --> + (modify <c7> ^min <vcom> ^min-net <nn>) + (modify <c4> ^max <vcom>) + (make pull-ff west <nn> <gx> <gy> <gy> <vcom>) + (modify <c5> ^grid-x <vcom> ^grid-layer <lay>) + (modify 1 ^present find-no-of-pins-on-a-row-col) +) + +(p p465 + { <c1> (context ^present remove-total-verti-gt1) } + --> + (modify <c1> ^present find-no-of-pins-on-a-row-col) +) + +(p p466 + { <c1> (context ^present extend-total-verti) } + --> + (modify <c1> ^present remove-total-verti-gt1) +) + +(p p467 + (context ^present remove-total-verti-gt1) + (total-verti ^5 > 1) + { <t> (total-verti ^5 1) } + --> + (remove <t>) +) + +(p p468 + { <c1> (context ^present remove-total-verti-gt1) } + (total-verti ^5 > 1) + - (total-verti ^5 1) + --> + (make remove-all-total-vertis) + (modify <c1> ^present extend-total-verti) +) + +(p p469 + { <c1> (context ^present remove-total-verti-gt1) } + { <c> (remove-all-total-vertis) } + - (total-verti) + --> + (remove <c>) + (modify <c1> ^present propagate-constraint) +) + +(p p470 + { <c1> (context ^present remove-total-verti-gt1) } + { <c> (remove-all-total-vertis) } + --> + (remove <c>) + (modify <c1> ^present find-no-of-pins-on-a-row-col) +) + +(p p471 + { <c1> (context ^present << extend-total-verti remove-total-verti-gt1 >>) } + - (total-verti) + --> + (modify <c1> ^present propagate-constraint) +) + +(p p515 + { <c> (context ^previous find-no-of-pins-on-a-row-col) } + - (total) + { <p> (pull-ff north <nn> <gx> <gy1> <gx> <gy2>) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^came-from south ^pin-name <pn>) } + { <v> (vertical ^net-name nil ^min <gy1> ^max >= <gy2> ^com <gx> ^layer <lay>) } + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + --> + (remove <p> <c>) + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^max <gy2>) + (modify <v> ^min <gy2> ^min-net <nn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p516 + { <c> (context ^previous find-no-of-pins-on-a-row-col) } + - (total) + { <p> (pull-ff south <nn> <gx> <gy1> <gx> <gy2>) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^came-from north ^pin-name <pn>) } + { <v> (vertical ^net-name nil ^min <= <gy2> ^max <gy1> ^com <gx> ^layer <lay>) } + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + --> + (remove <p> <c>) + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <gy2>) + (modify <v> ^max <gy2> ^max-net <nn>) + (modify <ff> ^grid-y <gy2> ^can-chng-layer nil) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p517 + { <c> (context ^previous find-no-of-pins-on-a-row-col) } + - (total) + { <p> (pull-ff east <nn> <gx1> <gy> <gx2> <gy>) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^came-from west ^pin-name <pn>) } + { <v> (horizontal ^net-name nil ^min <gx1> ^max >= <gx2> ^com <gy> ^layer <lay>) } + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove <p> <c>) + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^max <gx2>) + (modify <v> ^min <gx2> ^min-net <nn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p518 + { <c> (context ^previous find-no-of-pins-on-a-row-col) } + - (total) + { <p> (pull-ff west <nn> <gx1> <gy> <gx2> <gy>) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy1> ^grid-layer <lay> ^came-from east ^pin-name <pn>) } + { <v> (horizontal ^net-name nil ^min <= <gx2> ^max <gx1> ^com <gy> ^layer <lay>) } + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove <p> <c>) + (make (substr <v> 1 inf) ^net-name <nn> ^pin-name <pn> ^min <gx2>) + (modify <v> ^max <gx2> ^max-net <nn>) + (modify <ff> ^grid-x <gx2> ^can-chng-layer nil) + (make context ^present find-no-of-pins-on-a-row-col) +) + +(p p293 + (eliminate-total) + (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^min-xy <min1> ^max-xy <max1> ^level-pins <p1>) + { <t1> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^min-xy <min2> ^max-xy { <max2> > <max1> } ^level-pins < <p1>) } + - (total ^row-col <rc> ^coor <xy> ^max-xy < <min2>) + - (total ^row-col <rc> ^coor <xy> ^min-xy { > <max1> < <max2> }) + --> + (remove <t1>) +) + +(p p294 + (eliminate-total) + (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^min-xy <min1> ^max-xy <max1> ^level-pins <p1>) + { <t1> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^min-xy <min2> ^max-xy { <max2> < <max1> } ^level-pins < <p1>) } + - (total ^row-col <rc> ^coor <xy> ^max-xy < <min2>) + - (total ^row-col <rc> ^coor <xy> ^min-xy { > <max2> < <max1> }) + --> + (remove <t1>) +) + +(p p295 + (eliminate-total) + (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^min-xy <min1> ^max-xy <max1> ^level-pins <p1>) + { <t1> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^min-xy { <min2> < <min1> } ^max-xy <max2> ^level-pins < <p1>) } + - (total ^row-col <rc> ^coor <xy> ^min-xy > <max2>) + - (total ^row-col <rc> ^coor <xy> ^max-xy { > <min2> < <min1> }) + --> + (remove <t1>) +) + +(p p296 + (eliminate-total) + (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^min-xy <min1> ^max-xy <max1> ^level-pins <p1>) + { <t1> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^min-xy { <min2> > <min1> } ^max-xy <max2> ^level-pins < <p1>) } + - (total ^row-col <rc> ^coor <xy> ^min-xy > <max2>) + - (total ^row-col <rc> ^coor <xy> ^max-xy { > <min1> < <min2> }) + --> + (remove <t1>) +) + +(p p297 + (context ^present merge) + { <m> (merge-direction left) } + { <t1> (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^level-pins <lcou> ^total-pins <tcou> ^min-xy <min> ^max-xy <max>) } + - (rmerge) + - (total ^net-name <> <nn1> ^row-col <rc> ^coor <xy> ^max-xy < <max>) + (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^min-xy > <max>) + --> + (remove <m>) + (make merge-direction right) + (make lmerge <nn1> <rc> <xy> <min> <max> <lcou> <tcou> (substr <t1> nets inf)) +) + +(p p298 + (context ^present merge) + { <m> (merge-direction right) } + { <t1> (total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^level-pins <lcou> ^total-pins <tcou> ^min-xy <min> ^max-xy <max>) } + - (lmerge) + - (total ^net-name <> <nn1> ^row-col <rc> ^coor <xy> ^min-xy > <min>) + (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^max-xy < <min>) + --> + (remove <m>) + (make merge-direction left) + (make rmerge <nn1> <rc> <xy> <min> <max> <lcou> <tcou> (substr <t1> nets inf)) +) + +(p p299 + { <c> (lmerge <nn1> <rc> <xy> <min> <max> <lcou> <tcou>) } + { <t2> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins <cou3> ^total-pins <cou4> ^min-xy { <min1> > <max> } ^max-xy <max1>) } + - (total ^row-col <rc> ^coor <xy> ^min-xy > <max> ^max-xy < <min1>) + - (place-holder <rc> <xy> > <max> < <min1>) + --> + (make total ^net-name <nn1> ^row-col <rc> ^coor <xy> ^level-pins (compute <lcou> + <cou3>) ^total-pins (compute <tcou> + <cou4>) ^min-xy <min> ^max-xy <max1> ^nets (substr <c> 9 inf) (substr <t2> nets inf)) + (make delete-merged <nn2> <rc> <xy> <min1> <max1> (genatom)) +) + +(p p300 + { <c> (rmerge <nn1> <rc> <xy> <min> <max> <lcou> <tcou>) } + { <t2> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins <cou3> ^total-pins <cou4> ^min-xy <min1> ^max-xy { <max1> < <min> }) } + - (total ^row-col <rc> ^coor <xy> ^min-xy > <max1> ^max-xy < <min>) + - (place-holder <rc> <xy> > <max1> < <min>) + --> + (make total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins (compute <lcou> + <cou3>) ^total-pins (compute <tcou> + <cou4>) ^min-xy <min1> ^max-xy <max> ^nets (substr <c> 9 inf) (substr <t2> nets inf)) + (make rdelete-merged <nn2> <rc> <xy> <min1> <max1> (genatom)) +) + +(p p301 + { <d> (delete-merged <nn> <rc> <xy> <min> <max> <id>) } + (delete-merged <nn> <rc> <xy> <min> <max> <> <id>) + --> + (remove <d>) +) + +(p p302 + { <d> (rdelete-merged <nn> <rc> <xy> <min> <max> <id>) } + (rdelete-merged <nn> <rc> <xy> <min> <max> <> <id>) + --> + (remove <d>) +) + +(p p303 + (delete-merged <nn> <rc> <xy> <min> <max>) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max>) } + - (lmerge) + --> + (remove <t>) +) + +(p p304 + (rdelete-merged <nn> <rc> <xy> <min> <max>) + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max>) } + - (rmerge) + --> + (remove <t>) +) + +(p p305 + { <d> (<< delete-merged rdelete-merged >>) } + - (<< lmerge rmerge >>) + --> + (remove <d>) +) + +(p p306 + (delete-merged <nn> <rc> <xy> <min> <max>) + { <t1> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max> ^level-pins <cou1> ^total-pins <cou2>) } + { <t2> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins <cou3> ^total-pins <cou4> ^min-xy <min1> ^max-xy { <max1> < <min> }) } + - (lmerge) + --> + (make place-holder <rc> <xy> <min> <max> (genatom)) + (make total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins (compute <cou1> + <cou3>) ^total-pins (compute <cou2> + <cou4>) ^min-xy <min1> ^max-xy <max> ^nets (substr <t1> nets inf) (substr <t2> nets inf)) +) + +(p p307 + (rdelete-merged <nn> <rc> <xy> <min> <max>) + { <t1> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max> ^level-pins <cou1> ^total-pins <cou2>) } + { <t2> (total ^net-name <nn2> ^row-col <rc> ^coor <xy> ^level-pins <cou3> ^total-pins <cou4> ^min-xy { <min1> > <max> } ^max-xy <max1>) } + - (rmerge) + --> + (make place-holder <rc> <xy> <min> <max> (genatom)) + (make total ^net-name <nn> ^row-col <rc> ^coor <xy> ^level-pins (compute <cou1> + <cou3>) ^total-pins (compute <cou2> + <cou4>) ^min-xy <min> ^max-xy <max1> ^nets (substr <t1> nets inf) (substr <t2> nets inf)) +) + +(p p308 + { <p> (place-holder <rc> <xy> <min> <max> <id>) } + (place-holder <rc> <xy> <min> <max> <> <id>) + --> + (remove <p>) +) + +(p p309 + (<< lmerge rmerge >>) + { <p> (place-holder <rc> <xy> <min> <max> <id>) } + - (total ^row-col <rc> ^coor <xy> ^max-xy < <min>) + --> + (remove <p>) +) + +(p p310 + (<< lmerge rmerge >>) + { <p> (place-holder <rc> <xy> <min> <max> <id>) } + - (total ^row-col <rc> ^coor <xy> ^min-xy > <max>) + --> + (remove <p>) +) + +(p p311 + (context ^present merge) + { <l> (lmerge <nn> <rc> <xy> <min> <max>) } + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max>) } + --> + (remove <l> <t>) +) + +(p p312 + (context ^present merge) + { <l> (rmerge <nn> <rc> <xy> <min> <max>) } + { <t> (total ^net-name <nn> ^row-col <rc> ^coor <xy> ^min-xy <min> ^max-xy <max>) } + --> + (remove <l> <t>) +) + +(p p313 + (context ^present merge) + (total ^level-pins <cou> ^total-pins <cou>) + - (total ^level-pins { <cou1> > <cou> } ^total-pins <cou1>) + { <m> (maximum-total < <cou>) } + --> + (modify <m> ^2 <cou>) +) + +(p p314 + (context ^present merge) + (total ^row-col row ^coor 1 ^level-pins <cou> ^total-pins <cou>) + - (total ^row-col row ^coor 1 ^level-pins { <cou1> > <cou> } ^total-pins <cou1>) + { <m> (maximum-total ^5 1 < <cou>) } + --> + (modify <m> ^6 <cou>) +) + +(p p315 + (context ^present merge) + (last-row <lr>) + (total ^row-col row ^coor <lr> ^level-pins <cou> ^total-pins <cou>) + - (total ^row-col row ^coor <lr> ^level-pins { <cou1> > <cou> } ^total-pins <cou1>) + { <m> (maximum-total ^7 <lr> < <cou>) } + --> + (modify <m> ^8 <cou>) +) + +(p p316 + (context ^present merge) + (total ^level-pins <cou1> ^total-pins <cou2>) + - (total ^level-pins > <cou1> ^total-pins > <cou2>) + { <m> (maximum-total <garb4> { <min1> < <cou1> }) } + --> + (modify <m> ^3 <cou1> ^4 <cou2>) +) + +(p p317 + { <con> (context ^present merge) } + --> + (modify <con> ^present delete-totals) + (make goal cleanup eliminate-total) + (make goal cleanup merge-direction) +) + +(p p318 + (context ^present delete-totals) + (maximum-total <max> <garb1> <garb2>) + { <t> (total ^level-pins { <cou> < <max> } ^total-pins <> <cou>) } + --> + (remove <t>) +) + +(p p319 + (context ^present delete-totals) + (maximum-total ^5 1 ^6 <cou>) + { <t> (total ^row-col row ^coor 1 ^level-pins { <cou1> < <cou> } ^total-pins <cou1>) } + --> + (remove <t>) +) + +(p p320 + (context ^present delete-totals) + (maximum-total ^7 <lr> ^8 <cou>) + { <t> (total ^row-col row ^coor <lr> ^level-pins { <cou1> < <cou> } ^total-pins <cou1>) } + --> + (remove <t>) +) + +(p p321 + (context ^present delete-totals) + (maximum-total <garb1> <min> <max>) + { <t> (total ^level-pins { <cou> < <min> }) } + (last-row <lr>) + (total ^row-col row ^coor { <> 1 <> <lr> }) + --> + (remove <t>) +) + +(p p322 + (context ^present delete-totals) + (total ^row-col <rc> ^coor <xy> ^level-pins <min> ^total-pins <max>) + { <t1> (total ^row-col <rc> ^coor <xy> ^level-pins { <cou> <= <min> } ^total-pins > <max>) } + --> + (remove <t1>) +) + +(p p323 + (context ^present delete-totals) + { <m> (maximum-total <garb1> <garb2> <garb3>) } + --> + (remove <m>) +) + +(p p324 + { <c1> (context ^present delete-totals) } + - (maximum-total) + { <t1> (total ^net-name <nn1> ^row-col row ^coor 1) } + { <t2> (total ^net-name <nn2> ^row-col row ^coor <lr>) } + - (total ^row-col row ^coor { <> 1 <> <lr> }) + (last-row <lr>) + --> + (remove <c1> <t1> <t2>) + (make change-priority) + (make tran-total row 1 (substr <t1> nets inf) end) + (make tran-total row <lr> (substr <t2> nets inf) end) + (make goal cleanup total) +) + +(p p325 + (context ^present delete-totals) + - (maximum-total) + (total ^net-name <nn1> ^row-col row ^coor 1) + (total ^net-name <nn2> ^row-col row ^coor <lr>) + { <t1> (total ^net-name <> <nn1> ^row-col row ^coor 1) } + (last-row <lr>) + --> + (remove <t1>) +) + +(p p326 + { <t1> (tran-total <rc> <xy1> end) } + { <t2> (tran-total <rc> <> <xy1> end) } + --> + (remove <t2>) + (modify <t1> ^4 nil) +) + +(p p519 + (context ^present random1) + (net ^net-name <nn> ^net-no-of-pins 2) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn>) + (vertical-layer <lay>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> <= <gy1> } ^grid-layer <lay>) + (vertical ^net-name nil ^min { <vmin1> <= <gy1> } ^max { <vmax1> > <vmin1> >= <gy1> } ^com <gx1> ^layer <lay> ^compo <gx2> ^commo <cmo> ^min-net <vnn1>) + (vertical ^net-name nil ^min { <vmin2> <= <gy2> } ^max { <vmax2> > <vmin2> >= <gy2> >= <vmin1> } ^com <gx2> ^layer <lay> ^compo <cpo> ^commo <garb1> ^max-net <vnn2>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> >= <gx2> > <hmin> } ^com { <hcom> <= <vmax1> >= <vmin1> <= <vmax2> >= <vmin2> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + - (horizontal ^net-name <> nil ^com <hcom>) + --> + (remove 1 3 5) + (make vertical ^com <gx1> ^layer <lay> ^min <vmin1> ^max <hcom> ^compo <gx2> ^commo <cmo> ^min-net <vnn1> ^max-net <nn>) + (modify 6 ^min <gy1> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <lay> ^min <hcom> ^max <vmax2> ^compo <cpo> ^commo <gx1> ^min-net <nn> ^max-net <vnn2>) + (modify 7 ^max <gy2> ^max-net <nn>) + (make horizontal ^min <hmin> ^max <gx1> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 8 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <lay> ^min <hcom> ^max <gy1> ^commo <cmo> ^compo <gx2> ^net-name <nn> ^pin-name <pn>) + (make vertical ^com <gx2> ^layer <lay> ^max <hcom> ^min <gy2> ^commo <gx1> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <hcom> ^layer <lay> ^min <gx1> ^max <gx2> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p520 + (context ^present random1) + (net ^net-name <nn> ^net-no-of-pins 2) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn>) + (horizontal-layer <lay>) + (ff ^net-name <nn> ^grid-x { <gx2> >= <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <lay>) + (horizontal ^net-name nil ^min { <hmin1> <= <gx1> } ^max { <hmax1> > <hmin1> >= <gx1> } ^com <gy1> ^layer <lay> ^compo <gy2> ^commo <cmo> ^max-net <hnn1>) + (horizontal ^net-name nil ^min { <hmin2> <= <gx2> } ^max { <hmax2> > <hmin2> >= <gx2> >= <hmax1> } ^com <gy2> ^layer <lay> ^compo <cpo> ^commo <garb1> ^min-net <hnn2>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> >= <gy2> > <vmin> } ^com { <vcom> <= <hmax1> >= <hmin1> <= <hmax2> >= <hmin2> } ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + - (vertical ^net-name <> nil ^com <vcom>) + --> + (remove 1 3 5) + (make horizontal ^com <gy1> ^layer <lay> ^min <vcom> ^max <hmax1> ^compo <gy2> ^commo <cmo> ^min-net <nn> ^max-net <hnn1>) + (modify 6 ^max <gx1> ^max-net <nn>) + (make horizontal ^com <gy2> ^layer <lay> ^min <hmin2> ^max <vcom> ^compo <cpo> ^commo <gy1> ^min-net <hnn2> ^max-net <nn>) + (modify 7 ^min <gx2> ^min-net <nn>) + (make vertical ^min <vmin> ^max <gy1> ^com <vcom> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 8 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <lay> ^min <gx1> ^max <vcom> ^commo <cmo> ^compo <gy2> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <lay> ^min <vcom> ^max <gx2> ^commo <gy1> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (make vertical ^com <vcom> ^layer <lay> ^min <gy1> ^max <gy2> ^commo <vcmo> ^compo <vcpo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p521 + (context ^present random1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^com { <vcom1> > <gx> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { >= <gx> < <vcom1> }) + (vertical ^com { <vcom2> <= <vcom1> > <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <vcom2>) + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom2> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom2> ^max >= <vcom2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <= <vcom2> >= <gx> } ^layer <lay>) + - (ff ^net-name <nn> ^grid-x < <gx>) + - (ff ^grid-x <vcom2> ^grid-y <gy>) + --> + (make made-random-move) + (make horizontal ^min <hmin> ^layer <lay> ^max <gx> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <vcom2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <gx> ^max <vcom2> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify 2 ^grid-x <vcom2> ^grid-layer <lay> ^can-chng-layer nil ^came-from west) +) + +(p p522 + (context ^present random1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^com { <vcom1> < <gx> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { <= <gx> > <vcom1> }) + (vertical ^com { <vcom2> >= <vcom1> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcom2> ^max >= <gx>) + (horizontal ^net-name nil ^min { <hmin> <= <vcom2> } ^max { > <hmin> >= <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom2> ^max >= <vcom2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <= <gx> >= <vcom2> } ^layer <lay>) + - (ff ^net-name <nn> ^grid-x > <gx>) + - (ff ^grid-x <vcom2> ^grid-y <gy>) + --> + (make made-random-move) + (make horizontal ^min <hmin> ^layer <lay> ^max <vcom2> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <vcom2> ^max <gx> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify 2 ^grid-x <vcom2> ^grid-layer <lay> ^can-chng-layer nil ^came-from east) +) + +(p p523 + (context ^present random1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <vcom1> < <gx> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { <= <gx> > <vcom1> }) + (vertical ^com { <vcom2> >= <vcom1> < <gx> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcom2> ^max >= <gx>) + (horizontal ^net-name nil ^min { <hmin> <= <vcom2> } ^max { > <hmin> >= <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom2> ^max >= <vcom2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <= <gx> >= <vcom2> } ^layer <lay>) + - (ff ^net-name <nn> ^grid-x > <gx>) + - (ff ^grid-x <vcom2> ^grid-y <gy>) + --> + (make made-random-move) + (make horizontal ^min <hmin> ^layer <lay> ^max <vcom2> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <vcom2> ^max <gx> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify 2 ^grid-x <vcom2> ^grid-layer <lay> ^can-chng-layer nil ^came-from east) +) + +(p p524 + (context ^present random1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^com { <hcom1> < <gy> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom1> <= <gy> }) + (horizontal ^com { <hcom2> >= <hcom1> < <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <hcom2> ^max >= <gy>) + (vertical ^net-name nil ^min { <vmin> <= <hcom2> } ^max { > <vmin> >= <gy> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <hcom2> <= <gy> } ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom2> ^max >= <hcom2> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y > <gy>) + - (ff ^grid-x <gx> ^grid-y <hcom2>) + --> + (make made-random-move) + (make vertical ^min <vmin> ^layer <lay> ^max <hcom2> ^com <gx> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <hcom2> ^max <gy> ^commo <vcmo> ^compo <vcpo> ^layer <lay> ^com <gx>) + (modify 2 ^grid-y <hcom2> ^grid-layer <lay> ^can-chng-layer nil ^came-from north) +) + +(p p525 + (context ^present random1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^com { <hcom1> > <gy> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <hcom1> >= <gy> }) + (horizontal ^com { <hcom2> <= <hcom1> > <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <hcom2>) + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom2> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <gy> <= <hcom2> } ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom2> ^max >= <hcom2> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y < <gy>) + - (ff ^grid-x <gx> ^grid-y <hcom2>) + --> + (make made-random-move) + (make vertical ^min <vmin> ^layer <lay> ^max <gy> ^com <gx> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <hcom2> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <gy> ^max <hcom2> ^commo <vcmo> ^compo <vcpo> ^layer <lay> ^com <gx>) + (modify 2 ^grid-y <hcom2> ^grid-layer <lay> ^can-chng-layer nil ^came-from south) +) + +(p p526 + (context ^present random1) + --> + (remove 1) + (make context ^present check-random-move) +) + +(p p527 + { <c> (context ^present check-random-move) } + { <m> (made-random-move) } + --> + (remove <c> <m>) + (make context ^present check-for-routed-net) + (make goal cleanup made-random-move) +) + +(p p528 + { <c> (context ^present check-random-move) } + - (made-random-move) + --> + (remove <c>) + (make context ^present random2) +) + +(p p529 + (context ^present random2) + --> + (write (crlf) |Sorry, I can not proceed anymore because of my ignorance.|) + (halt) +) + +(p p530 + (context ^present random0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + - (ff ^net-name <nn> ^pin-name <> <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^com { <hcom1> < <gy> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { > <hcom1> <= <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <hcom1> ^max >= <gy>) + (vertical ^net-name nil ^min { <vmin> <= <hcom1> } ^max { > <vmin> >= <gy> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + (vertical-layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <hcom1> <= <gy> } ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom1> ^max >= <hcom1> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y > <gy>) + --> + (remove 1) + (make vertical ^min <vmin> ^layer <lay> ^max <hcom1> ^com <gx> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn>) + (modify 4 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <hcom1> ^max <gy> ^commo <vcmo> ^compo <vcpo> ^layer <lay> ^com <gx>) + (modify 2 ^grid-y <hcom1> ^grid-layer <lay> ^can-chng-layer nil ^came-from north) + (make context ^present propagate-constraint) +) + +(p p531 + (context ^present random0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + - (ff ^net-name <nn> ^pin-name <> <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^com { <hcom1> > <gy> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^com { < <hcom1> >= <gy> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <hcom1>) + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { > <vmin> >= <hcom1> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + (vertical-layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { >= <gy> <= <hcom1> } ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <hcom1> ^max >= <hcom1> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y < <gy>) + --> + (remove 1) + (make vertical ^min <vmin> ^layer <lay> ^max <gy> ^com <gx> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn>) + (modify 4 ^min <hcom1> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <gy> ^max <hcom1> ^commo <vcmo> ^compo <vcpo> ^layer <lay> ^com <gx>) + (modify 2 ^grid-y <hcom1> ^grid-layer <lay> ^can-chng-layer nil ^came-from south) + (make context ^present propagate-constraint) +) + +(p p532 + (context ^present random0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + - (ff ^net-name <nn> ^pin-name <> <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^com { <vcom1> < <gx> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { <= <gx> > <vcom1> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcom1> ^max >= <gx>) + (horizontal ^net-name nil ^min { <hmin> <= <vcom1> } ^max { > <hmin> >= <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + (horizontal-layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom1> ^max >= <vcom1> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { >= <vcom1> <= <gx> } ^layer <lay>) + - (ff ^net-name <nn> ^grid-x > <gx>) + --> + (remove 1) + (make horizontal ^min <hmin> ^layer <lay> ^max <vcom1> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify 4 ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <vcom1> ^max <gx> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify 2 ^grid-x <vcom1> ^grid-layer <lay> ^can-chng-layer nil ^came-from east) + (make context ^present propagate-constraint) +) + +(p p533 + (context ^present random0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + - (ff ^net-name <nn> ^pin-name <> <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^com { <vcom1> > <gx> }) + - (vertical ^status nil ^net-name { <nn> <> nil } ^com { >= <gx> < <vcom1> }) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <vcom1>) + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { > <hmin> >= <vcom1> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + (horizontal-layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <vcom1> ^max >= <vcom1> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { >= <gx> <= <vcom1> } ^layer <lay>) + - (ff ^net-name <nn> ^grid-x < <gx>) + --> + (remove 1) + (make horizontal ^min <hmin> ^layer <lay> ^max <gx> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify 4 ^min <vcom1> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <gx> ^max <vcom1> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify 2 ^grid-x <vcom1> ^grid-layer <lay> ^can-chng-layer nil ^came-from west) + (make context ^present propagate-constraint) +) + +(p p534 + { <c> (context ^present random2) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (vertical ^status nil ^net-name { <nn> <> nil } ^com > <gx>) + { <h> (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> > <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) } + (congestion ^direction col ^coordinate <gx2> ^como <gx>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + --> + (make horizontal ^min <hmin> ^layer <lay> ^max <gx> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify <h> ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <gx> ^max <gx2> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify <ff> ^grid-x <gx2> ^grid-layer <lay> ^can-chng-layer nil ^came-from west) + (remove <c>) + (make context ^present check-for-routed-net) +) + +(p p535 + { <c> (context ^present random2) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (vertical ^status nil ^net-name { <nn> <> nil } ^com < <gx>) + { <h> (horizontal ^net-name nil ^min { <hmin> < <gx> } ^max { <hmax> >= <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) } + (congestion ^direction col ^coordinate <gx> ^como <gx2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + --> + (make horizontal ^min <hmin> ^layer <lay> ^max <gx2> ^com <gy> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify <h> ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^min <gx2> ^max <gx> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gy>) + (modify <ff> ^grid-x <gx2> ^grid-layer <lay> ^can-chng-layer nil ^came-from east) + (remove <c>) + (make context ^present check-for-routed-net) +) + +(p p536 + { <c> (context ^present random2) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^com > <gy>) + { <h> (vertical ^net-name nil ^min { <hmin> <= <gy> } ^max { <hmax> > <gy> } ^com <gx> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) } + (congestion ^direction row ^coordinate <gy2> ^como <gy>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + --> + (make vertical ^min <hmin> ^layer <lay> ^max <gy> ^com <gx> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify <h> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <gy> ^max <gy2> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gx>) + (modify <ff> ^grid-y <gy2> ^grid-layer <lay> ^can-chng-layer nil ^came-from south) + (remove <c>) + (make context ^present check-for-routed-net) +) + +(p p537 + { <c> (context ^present random2) } + { <ff> (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) } + (horizontal ^status nil ^net-name { <nn> <> nil } ^com < <gy>) + { <h> (vertical ^net-name nil ^min { <hmin> < <gy> } ^max { <hmax> >= <gy> } ^com <gx> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) } + (congestion ^direction row ^coordinate <gy> ^como <gy2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + --> + (make vertical ^min <hmin> ^layer <lay> ^max <gy2> ^com <gx> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn>) + (modify <h> ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^min <gy2> ^max <gy> ^commo <hcmo> ^compo <hcpo> ^layer <lay> ^com <gx>) + (modify <ff> ^grid-y <gy2> ^grid-layer <lay> ^can-chng-layer nil ^came-from north) + (remove <c>) + (make context ^present check-for-routed-net) +) + +(p p558 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> <= <nmax> } ^grid-y <gy>) + - (ff ^net-name <nn> ^grid-x { > <gx1> < <gx2> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (horizontal ^net-name nil ^min <= <gx1> ^max >= <gx2> ^com <gy> ^layer <> <lay>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx1> ^max >= <gx2> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2 3) + (make horizontal ^com <gy> ^min <min> ^max <gx1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx1> ^max <gx2> ^net-name <nn> ^pin-name <pn>) +) + +(p p559 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx2> > <gx1> <= <nmax> }) + - (ff ^net-name <nn> ^grid-x { > <gx1> < <gx2> } ^grid-y <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx1> < <gx2> }) + (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx1> ^max >= <gx2> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2) + (make horizontal ^com <gy> ^min <min> ^max <gx1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx1> ^max <gx2> ^net-name <nn> ^pin-name <pn>) +) + +(p p560 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx2> < <gx1> >= <nmin> }) + - (ff ^net-name <nn> ^grid-x { < <gx1> > <gx2> } ^grid-y <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { < <gx1> > <gx2> }) + (horizontal ^net-name nil ^min { <min> <= <gx2> } ^max { <max> >= <gx1> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx2> ^max >= <gx1> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2) + (make horizontal ^com <gy> ^min <min> ^max <gx2> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx1> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx2> ^max <gx1> ^net-name <nn> ^pin-name <pn>) +) + +(p p561 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx2> > <gx1> <= <nmax> }) + - (ff ^net-name <nn> ^grid-x { > <gx1> < <gx2> } ^grid-y <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { > <gx1> < <gx2> }) + (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (horizontal-layer <lay>) + (dominant-layer) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx1> ^max >= <gx2> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2) + (make horizontal ^com <gy> ^min <min> ^max <gx1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx1> ^max <gx2> ^net-name <nn> ^pin-name <pn>) +) + +(p p562 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { <gx2> < <gx1> >= <nmin> }) + - (ff ^net-name <nn> ^grid-x { < <gx1> > <gx2> } ^grid-y <gy>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com { < <gx1> > <gx2> }) + (horizontal ^net-name nil ^min { <min> <= <gx2> } ^max { <max> >= <gx1> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (horizontal-layer <lay>) + (dominant-layer) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx2> ^max >= <gx1> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2) + (make horizontal ^com <gy> ^min <min> ^max <gx2> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx1> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx2> ^max <gx1> ^net-name <nn> ^pin-name <pn>) +) + +(p p563 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x { <gx1> >= <nmin> <= <nmax> } ^grid-y <gy> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> <= <nmax> } ^grid-y <gy>) + - (ff ^net-name <nn> ^grid-x { > <gx1> < <gx2> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx1> } ^max { <max> >= <gx2> } ^max { <max> >= <gx2> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (horizontal-layer <lay>) + (dominant-layer) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx1> ^max >= <gx2> ^com <gy>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <gy> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx1> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + --> + (remove 2 3) + (make horizontal ^com <gy> ^min <min> ^max <gx1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make horizontal ^com <gy> ^min <gx2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gx1> ^max <gx2> ^net-name <nn> ^pin-name <pn>) +) + +(p p564 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy1> <= <nmax> } ^grid-x <gx>) + - (ff ^net-name <nn> ^grid-y { > <gy1> < <gy2> } ^grid-x <gx>) + (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (vertical ^net-name nil ^min <= <gy1> ^max >= <gy2> ^com <gx> ^layer <> <lay>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy1> ^max >= <gy2> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2 3) + (make vertical ^com <gx> ^min <min> ^max <gy1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy1> ^max <gy2> ^net-name <nn> ^pin-name <pn>) +) + +(p p565 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy2> > <gy1> <= <nmax> }) + - (ff ^net-name <nn> ^grid-y { > <gy1> < <gy2> } ^grid-x <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy1> < <gy2> }) + (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy1> ^max >= <gy2> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2) + (make vertical ^com <gx> ^min <min> ^max <gy1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy1> ^max <gy2> ^net-name <nn> ^pin-name <pn>) +) + +(p p566 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy2> < <gy1> >= <nmin> }) + - (ff ^net-name <nn> ^grid-y { > <gy2> < <gy1> } ^grid-x <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy2> < <gy1> }) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { <max> >= <gy1> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy2> ^max >= <gy1> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2) + (make vertical ^com <gx> ^min <min> ^max <gy2> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy1> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy2> ^max <gy1> ^net-name <nn> ^pin-name <pn>) +) + +(p p567 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy2> > <gy1> <= <nmax> }) + - (ff ^net-name <nn> ^grid-y { > <gy1> < <gy2> } ^grid-x <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy1> < <gy2> }) + (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (vertical-layer <lay>) + (dominant-layer) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy1> ^max >= <gy2> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2) + (make vertical ^com <gx> ^min <min> ^max <gy1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy1> ^max <gy2> ^net-name <nn> ^pin-name <pn>) +) + +(p p568 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { <gy2> < <gy1> >= <nmin> }) + - (ff ^net-name <nn> ^grid-y { > <gy2> < <gy1> } ^grid-x <gx>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com { > <gy2> < <gy1> }) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { <max> >= <gy1> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (vertical-layer <lay>) + (dominant-layer) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy2> ^max >= <gy1> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2) + (make vertical ^com <gx> ^min <min> ^max <gy2> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy1> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy2> ^max <gy1> ^net-name <nn> ^pin-name <pn>) +) + +(p p569 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy1> >= <nmin> <= <nmax> } ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy1> <= <nmax> } ^grid-x <gx>) + - (ff ^net-name <nn> ^grid-y { > <gy1> < <gy2> } ^grid-x <gx>) + (vertical ^net-name nil ^min { <min> <= <gy1> } ^max { <max> >= <gy2> > <min> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <nn1> ^max-net <nn2>) + (vertical-layer <lay>) + (dominant-layer) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy1> ^max >= <gy2> ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy1> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <gx> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (remove 2 3) + (make vertical ^com <gx> ^min <min> ^max <gy1> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn1> ^max-net <nn>) + (make vertical ^com <gx> ^min <gy2> ^max <max> ^compo <cpo> ^commo <cmo> ^layer <lay> ^min-net <nn> ^max-net <nn2>) + (modify 4 ^min <gy1> ^max <gy2> ^net-name <nn> ^pin-name <pn>) +) + +(p p570 + (next-segment <nn> row <gy> nil <nmin> <nmax>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <max> >= <nmin> <= <nmax> } ^com <gy> ^layer <garb2> ^compo <garb3> ^commo <garb4> ^pin-name <pn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <max> ^max > <max> ^com <gy>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min { <min> > <max> <= <nmax> } ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <min> ^max >= <min> ^com <gy>) + (horizontal ^net-name nil ^min <max> ^max { <min> > <max> } ^com <gy> ^layer <garb5> ^compo <garb6> ^commo <garb7>) + --> + (modify 4 ^net-name <nn> ^pin-name <pn> ^max-net nil ^min-net nil) +) + +(p p571 + (next-segment <nn> col <gx> nil <nmin> <nmax>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <garb1> ^max { <max> >= <nmin> <= <nmax> } ^com <gx> ^layer <garb2> ^compo <garb3> ^commo <garb4> ^pin-name <pn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <max> ^max > <max> ^com <gx>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min { <min> > <max> <= <nmax> } ^com <gx>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <min> ^max >= <min> ^com <gx>) + (vertical ^net-name nil ^min <max> ^max { <min> > <max> } ^com <gx> ^layer <garb5> ^compo <garb6> ^commo <garb7>) + --> + (modify 4 ^net-name <nn> ^pin-name <pn> ^max-net nil ^min-net nil) +) + +(p p572 + { <next> (next-segment <nn> row <gy>) } + (ff ^net-name <nn> ^grid-y <gy> ^pin-name <pn> ^came-from north) + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <np> ^no-of-bottom-pins <garb1>) + - (ff ^net-name <nn> ^grid-y < <gy>) + { <ff> (ff ^net-name <nn> ^grid-y { <gy2> > <gy> } ^pin-name <pn2> ^grid-x <gx> ^grid-layer <lay> ^came-from north) } + { <v1> (vertical ^net-name nil ^min { <min> <= <gy> } ^max { > <min> >= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <mn>) } + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^com { < <gy2> >= <gy> } ^layer <lay>) + --> + (make vertical ^net-name nil ^max <gy> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify <v1> ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn2>) + (modify <ff> ^grid-y <gy> ^can-chng-layer nil) + (modify <next> ^5 useless) +) + +(p p573 + { <next> (next-segment <nn> row <gy>) } + (ff ^came-from south ^net-name <nn> ^grid-y <gy> ^pin-name <pn>) + (net ^net-name <nn> ^net-no-of-pins <np> ^no-of-top-pins <garb1> ^no-of-bottom-pins <np>) + - (ff ^net-name <nn> ^grid-y > <gy>) + { <ff> (ff ^net-name <nn> ^grid-y { <gy2> < <gy> } ^pin-name <pn2> ^grid-x <gx> ^grid-layer <lay> ^came-from south) } + { <v1> (vertical ^net-name nil ^max { <max> >= <gy> } ^min { < <max> <= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) } + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^com { > <gy2> <= <gy> } ^layer <lay>) + --> + (make vertical ^net-name nil ^max <max> ^min <gy> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <nn> ^max-net <mn>) + (modify <v1> ^max <gy2> ^max-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <gy2> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn2>) + (modify <ff> ^grid-y <gy> ^can-chng-layer nil) + (modify <v1> ^5 useless) +) + +(p p574 + (next-segment <nn> row <gy> <gg1> <nmin> <nmax>) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy> } ^grid-x { <gx> >= <nmin> <= <nmax> } ^grid-layer <lay> ^pin-name <pn>) + (vertical ^net-name nil ^min { <min> <= <gy> } ^max { > <min> >= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <mn>) + (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy2> ^com <gx>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^com <gx>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <gy> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify 3 ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy2> ^min <gy> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <gy> ^can-chng-layer nil) + (modify 1 ^2 <nn>) +) + +(p p575 + (next-segment <nn> row <gy> <gg1> <nmin> <nmax>) + (vertical ^net-name { <nn> <> nil } ^min { <gy2> > <gy> } ^com { <gx> >= <nmin> <= <nmax> } ^layer <lay> ^pin-name <pn>) + (vertical ^net-name nil ^min { < <gy2> <= <gy> } ^max <gy2> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + (vertical-s ^net-name <nn> ^min <= <gy> ^max >= <gy2> ^com <gx>) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy2>) + - (vertical ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy2> ^com <gx>) + - (ff ^net-name <> <nn> ^grid-x <gx>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + --> + (modify 3 ^max <gy> ^max-net <nn>) + (modify 2 ^min <gy>) + (make ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) + (modify 1 ^2 <nn>) +) + +(p p576 + (next-segment <nn> row <gy> <gg1> <nmin> <nmax>) + (ff ^net-name <nn> ^grid-y { <gy2> < <gy> } ^grid-x { <gx> >= <nmin> <= <nmax> } ^grid-layer <lay> ^pin-name <pn>) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { > <min> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <mn>) + (vertical-s ^net-name <nn> ^min <= <gy2> ^max >= <gy> ^com <gx>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^com <gx>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <gy2> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify 3 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <gy2> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <gy> ^can-chng-layer nil) + (modify 1 ^2 <nn>) +) + +(p p577 + (next-segment <nn> row <gy> <gg1> <nmin> <nmax>) + (vertical ^net-name { <nn> <> nil } ^min { <gy2> < <gy> } ^com { <gx> >= <nmin> <= <nmax> } ^layer <lay> ^pin-name <pn>) + (vertical ^net-name nil ^min <gy2> ^max { > <gy2> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo>) + (vertical-s ^net-name <nn> ^min <= <gy2> ^max >= <gy> ^com <gx>) + - (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy2>) + - (vertical ^net-name { <nn> <> nil } ^min <= <gy2> ^max >= <gy> ^com <gx>) + - (ff ^net-name <> <nn> ^grid-x <gx>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^com <gx>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + --> + (modify 3 ^min <gy> ^min-net <nn>) + (modify 2 ^max <gy>) + (make ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from south) + (modify 1 ^2 <nn>) +) + +(p p578 + (next-segment <nn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <garb2>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy> ^layer <garb3> ^compo <garb4> ^commo <garb5>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx> ^layer <garb6> ^compo <garb7> ^commo <garb8>) + --> + (remove 2) +) + +(p p579 + (next-segment <nn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <garb1> ^pin-name <garb2>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <gx> ^max <gx> ^com <gy>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <gx> ^max > <gx> ^com <gy>) + --> + (remove 2) +) + +(p p580 + (change-priority) + { <n> (next-segment ^5 useless) } + --> + (modify <n> ^5 nil) +) + +(p p581 + (change-priority) + { <n> (next-segment <nn> col <x> useless <min> <max>) } + (vertical-s ^net-name <nn> ^com <x> ^sum 2 ^difference 0) + (last-row <lr>) + --> + (modify <n> ^5 nil 1 <lr>) +) + +(p p582 + (change-priority) + { <n> (next-segment <nn> row <y> useless <min> <max>) } + (horizontal-s ^net-name <nn> ^com <x> ^sum 2 ^difference 0) + (last-col <lc>) + --> + (modify <n> ^5 nil 1 <lc>) +) + +(p p583 + { <n> (next-segment <nn> <rc> <xy> nil) } + - (next-segment ^5 <> nil) + --> + (remove <n>) + (make move-ff <nn> <rc> <xy>) +) + +(p p584 + { <c> (change-priority) } + --> + (remove <c>) + (make end-of-specialized-move-ff) +) + +(p p585 + (move-ff <nn> row <xy>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <xy> ^layer <lay> ^compo <cpo> ^commo <garb1>) + { <ff> (ff ^came-from south ^net-name { <nn1> <> <nn> } ^grid-x { <gx> >= <min> <= <max> } ^grid-y <xy> ^grid-layer { <flay> <> <lay> }) } + { <v1> (vertical ^status nil ^net-name <nn1> ^min < <xy> ^max <xy> ^com <gx> ^layer <flay>) } + - (horizontal ^net-name nil ^min <= <gx> ^max >= <gx> ^com <xy> ^layer <flay>) + { <v2> (vertical ^net-name nil ^min <xy> ^max { <garb4> > <xy> } ^com <gx> ^layer <flay> ^compo <garb2> ^commo <garb3>) } + --> + (modify <v2> ^min <cpo> ^min-net <nn1>) + (modify <v1> ^max <cpo>) + (modify <ff> ^grid-y <cpo> ^can-chng-layer nil) +) + +(p p586 + (move-ff <nn> row <xy>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min> ^max <max> ^com <xy> ^layer <lay> ^compo <garb1> ^commo <cmo>) + { <ff> (ff ^came-from north ^net-name { <nn1> <> <nn> } ^grid-x { <gx> >= <min> <= <max> } ^grid-y <xy> ^grid-layer { <flay> <> <lay> }) } + { <v1> (vertical ^status nil ^net-name <nn1> ^min <xy> ^max > <xy> ^com <gx> ^layer <flay>) } + - (horizontal ^net-name nil ^min <= <gx> ^max >= <gx> ^com <xy> ^layer <flay>) + { <v2> (vertical ^net-name nil ^min <vmin> ^max { <xy> > <vmin> } ^com <gx> ^layer <flay> ^compo <garb2> ^commo <garb3>) } + --> + (modify <v2> ^max <cmo> ^max-net <nn1>) + (modify <v1> ^min <cmo>) + (modify <ff> ^grid-y <cmo> ^can-chng-layer nil) +) + +(p p587 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <min> ^max <max>) + { <h> (horizontal-s ^net-name <nn> ^min <min> ^max <max>) } + --> + (remove <h>) +) + +(p p588 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <min> ^max <max>) + { <v> (vertical-s ^net-name <nn> ^min <min> ^max <max>) } + --> + (remove <v>) +) + +(p p589 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (ff ^net-name <nn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y { <gy> < <com> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <gy> } ^max { <vmax> >= <com> } ^com <gx> ^id <id>) } + (vertical ^net-name nil ^min <= <gy> ^max >= <com> ^com <gx>) + - (vertical-s ^net-name <> <nn> ^com <gx>) + --> + (remove <v>) + (make next-segment <nn> col <gx> nil <vmin> <vmax>) +) + +(p p590 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (ff ^net-name <nn> ^grid-x { <gx> >= <min> <= <max> } ^grid-y { <gy> > <com> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <com> } ^max { <vmax> >= <gy> } ^com <gx> ^id <id>) } + (vertical ^net-name nil ^min <= <com> ^max >= <gy> ^com <gx>) + - (vertical-s ^net-name <> <nn> ^com <gx>) + --> + (remove <v>) + (make next-segment <nn> col <gx> nil <vmin> <vmax>) +) + +(p p591 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (horizontal ^net-name <nn> ^min { <hmin2> >= <hmin1> } ^max { <hmax2> <= <hmax1> } ^com { <hcom2> < <hcom1> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <hcom2> } ^max { <vmax> >= <hcom1> } ^com { <vcom> >= <hmin2> <= <hmax2> } ^id <id>) } + (vertical ^net-name nil ^min <= <hcom2> ^max >= <hcom1> ^com { <vcom2> >= <hmin2> <= <hmax2> }) + - (vertical-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> col <vcom2> nil <vmin> <vmax>) +) + +(p p592 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (horizontal ^net-name <nn> ^min { <hmin2> >= <hmin1> } ^max { <hmax2> <= <hmax1> } ^com { <hcom2> > <hcom1> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <hcom1> } ^max { <vmax> >= <hcom2> } ^com { <vcom> >= <hmin2> <= <hmax2> } ^id <id>) } + (vertical ^net-name nil ^min <= <hcom1> ^max >= <hcom2> ^com { <vcom2> >= <hmin2> <= <hmax2> }) + - (vertical-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> col <vcom2> nil <vmin> <vmax>) +) + +(p p593 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (horizontal ^net-name <nn> ^min { <hmin2> >= <hmin1> <= <hmax1> } ^max { <hmax2> >= <hmax1> } ^com { <hcom2> < <hcom1> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <hcom2> } ^max { <vmax> >= <hcom1> } ^com { <vcom> >= <hmin2> <= <hmax1> } ^id <id>) } + (vertical ^net-name nil ^min <= <hcom2> ^max >= <hcom1> ^com { <vcom2> >= <hmin2> <= <hmax1> }) + - (vertical-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> col <vcom2> nil <vmin> <vmax>) +) + +(p p594 + (move-ff <nn>) + (horizontal ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (horizontal ^net-name <nn> ^min { <hmin2> >= <hmin1> <= <hmax1> } ^max { <hmax2> >= <hmax1> } ^com { <hcom2> > <hcom1> }) + { <v> (vertical-s ^net-name <nn> ^min { <vmin> <= <hcom1> } ^max { <vmax> >= <hcom2> } ^com { <vcom> >= <hmin2> <= <hmax1> } ^id <id>) } + (vertical ^net-name nil ^min <= <hcom1> ^max >= <hcom2> ^com { <vcom2> >= <hmin2> <= <hmax1> }) + - (vertical-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> col <vcom2> nil <vmin> <vmax>) +) + +(p p595 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (ff ^net-name <nn> ^grid-x { <gx> < <com> } ^grid-y { <gy> >= <min> <= <max> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <gx> } ^max { <vmax> >= <com> } ^com <gy> ^id <id>) } + (horizontal ^net-name nil ^min <= <gx> ^max >= <com> ^com <gy>) + - (horizontal-s ^net-name <> <nn> ^com <gy>) + --> + (remove <v>) + (make next-segment <nn> row <gy> nil <vmin> <vmax>) +) + +(p p596 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <min> ^max <max> ^com <com>) + (ff ^net-name <nn> ^grid-x { <gx> > <com> } ^grid-y { <gy> >= <min> <= <max> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <com> } ^max { <vmax> >= <gx> } ^com <gy> ^id <id>) } + (horizontal ^net-name nil ^min <= <com> ^max >= <gx> ^com <gy>) + - (horizontal-s ^net-name <> <nn> ^com <gy>) + --> + (remove <v>) + (make next-segment <nn> row <gy> nil <vmin> <vmax>) +) + +(p p597 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (vertical ^net-name <nn> ^min { <hmin2> >= <hmin1> } ^max { <hmax2> <= <hmax1> } ^com { <hcom2> < <hcom1> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <hcom2> } ^max { <vmax> >= <hcom1> } ^com { <vcom> >= <hmin2> <= <hmax2> } ^id <id>) } + (horizontal ^net-name nil ^min <= <hcom2> ^max >= <hcom1> ^com { <vcom2> >= <hmin2> <= <hmax2> }) + - (horizontal-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> row <vcom2> nil <vmin> <vmax>) +) + +(p p598 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (vertical ^net-name <nn> ^min { <hmin2> >= <hmin1> } ^max { <hmax2> <= <hmax1> } ^com { <hcom2> > <hcom1> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <hcom1> } ^max { <vmax> >= <hcom2> } ^com { <vcom> >= <hmin2> <= <hmax2> } ^id <id>) } + (horizontal ^net-name nil ^min <= <hcom1> ^max >= <hcom2> ^com { <vcom2> >= <hmin2> <= <hmax2> }) + - (horizontal-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> row <vcom2> nil <vmin> <vmax>) +) + +(p p599 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (vertical ^net-name <nn> ^min { <hmin2> >= <hmin1> <= <hmax1> } ^max { <hmax2> >= <hmax1> } ^com { <hcom2> < <hcom1> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <hcom2> } ^max { <vmax> >= <hcom1> } ^com { <vcom> >= <hmin2> <= <hmax1> } ^id <id>) } + (horizontal ^net-name nil ^min <= <hcom2> ^max >= <hcom1> ^com { <vcom2> >= <hmin2> <= <hmax1> }) + - (horizontal-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> row <vcom2> nil <vmin> <vmax>) +) + +(p p600 + (move-ff <nn>) + (vertical ^net-name <nn> ^min <hmin1> ^max <hmax1> ^com <hcom1>) + (vertical ^net-name <nn> ^min { <hmin2> >= <hmin1> <= <hmax1> } ^max { <hmax2> >= <hmax1> } ^com { <hcom2> > <hcom1> }) + { <v> (horizontal-s ^net-name <nn> ^min { <vmin> <= <hcom1> } ^max { <vmax> >= <hcom2> } ^com { <vcom> >= <hmin2> <= <hmax1> } ^id <id>) } + (horizontal ^net-name nil ^min <= <hcom1> ^max >= <hcom2> ^com { <vcom2> >= <hmin2> <= <hmax1> }) + - (horizontal-s ^net-name <> <nn> ^com <vcom2>) + --> + (remove <v>) + (make next-segment <nn> row <vcom2> nil <vmin> <vmax>) +) + +(p p601 + { <m> (move-ff) } + --> + (remove <m>) +) + +(p p602 + { <e> (end-of-specialized-move-ff) } + - (next-segment) + --> + (remove <e>) + (make context ^present check-for-routed-net) +) + +(p p603 + (context ^present << check-for-routed-net propagate-constraint >>) + (<< dominant-layer change-priority next-segment >>) + --> + (remove 2) +) + +(p p244 + (context ^present lshape1) + (<< total-verti counted-verti total counted >>) + --> + (remove 2) +) + +(p p245 + (context ^present lshape1) + (last-row <gy>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) + - (ff ^net-name <nn> ^grid-y <gy> ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> } ^grid-y <gy2>) + - (vertical ^com { > <gx> < <gx2> }) + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy> ^layer <lay> ^commo <hcmo> ^compo <hcpo> ^min-net <mn>) + - (pin ^pin-x <gx2> ^pin-y <hcpo>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> nil <> <nn> } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + --> + (make horizontal ^layer <lay> ^min <hmin> ^max <gx> ^min-net <mn> ^max-net <nn> ^com <gy> ^commo <hcmo> ^compo <hcpo>) + (modify 5 ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gx> ^max <gx2> ^com <gy> ^commo <hcmo> ^compo <hcpo>) + (modify 3 ^grid-x <gx2> ^came-from west) +) + +(p p246 + (context ^present lshape1) + (last-row <gy>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) + - (ff ^net-name <nn> ^grid-y <gy> ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx> } ^grid-y <gy2>) + - (vertical ^com { > <gx2> < <gx> }) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx> } ^com <gy> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (pin ^pin-x <gx2> ^pin-y <hcpo>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy> ^max >= <gy> ^com <gx2> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <gy> ^layer <lay>) + --> + (make horizontal ^layer <lay> ^min <hmin> ^max <gx2> ^min-net <mn> ^max-net <nn> ^com <gy> ^commo <hcmo> ^compo <hcpo>) + (modify 5 ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gx2> ^max <gx> ^com <gy> ^commo <hcmo> ^compo <hcpo>) + (modify 3 ^grid-x <gx2> ^came-from east) +) + +(p p247 + (context ^present lshape1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y 1 ^grid-layer <lay> ^pin-name <pn> ^came-from south) + - (ff ^net-name <nn> ^grid-y 1 ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> } ^grid-y <gy2>) + - (vertical ^com { > <gx> < <gx2> }) + (horizontal ^net-name nil ^min { <hmin> <= <gx> } ^max { <hmax> > <hmin> >= <gx2> } ^com 1 ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (pin ^pin-x <gx2> ^pin-y 0) + - (vertical ^net-name { <> <nn> <> nil } ^min <= 1 ^max >= 1 ^com <gx2> ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com 1 ^layer <lay>) + --> + (make horizontal ^layer <lay> ^min <hmin> ^max <gx> ^min-net <mn> ^max-net <nn> ^com 1 ^commo <hcmo> ^compo <hcpo>) + (modify 4 ^min <gx2> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gx> ^max <gx2> ^com 1 ^commo <hcmo> ^compo <hcpo>) + (modify 2 ^grid-x <gx2> ^came-from west) +) + +(p p248 + (context ^present lshape1) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y 1 ^grid-layer <lay> ^pin-name <pn> ^came-from south) + - (ff ^net-name <nn> ^grid-y 1 ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx> } ^grid-y <gy2>) + - (vertical ^com { > <gx2> < <gx> }) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx> } ^com 1 ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (pin ^pin-x <gx2> ^pin-y 0) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= 1 ^max >= 1 ^com <gx2> ^layer <lay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com 1 ^layer <lay>) + --> + (make horizontal ^layer <lay> ^min <hmin> ^max <gx2> ^min-net <mn> ^max-net <nn> ^com 1 ^commo <hcmo> ^compo <hcpo>) + (modify 4 ^min <gx> ^min-net <nn>) + (make horizontal ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gx2> ^max <gx> ^com 1 ^commo <hcmo> ^compo <hcpo>) + (modify 2 ^grid-x <gx2> ^came-from east) +) + +(p p249 + (context ^present lshape1) + (last-col <gx>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from east) + - (ff ^net-name <nn> ^grid-x <gx> ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x <gx2> ^grid-y { <gy2> > <gy> }) + - (horizontal ^com { > <gy> < <gy2> }) + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { <vmax> >= <gy2> > <vmin> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (pin ^pin-x <vcpo> ^pin-y <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (make vertical ^layer <lay> ^min <vmin> ^max <gy> ^min-net <mn> ^max-net <nn> ^com <gx> ^commo <vcmo> ^compo <vcpo>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gy> ^max <gy2> ^com <gx> ^commo <vcmo> ^compo <vcpo>) + (modify 3 ^grid-y <gy2> ^came-from south) +) + +(p p250 + (context ^present lshape1) + (last-col <gx>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from east) + - (ff ^net-name <nn> ^grid-x <gx> ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x <gx2> ^grid-y { <gy2> < <gy> }) + - (horizontal ^com { > <gy2> < <gy> }) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> >= <gy> > <vmin> } ^com <gx> ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (pin ^pin-x <vcpo> ^pin-y <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= <gx> ^max >= <gx> ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <gx> ^layer <lay>) + --> + (make vertical ^layer <lay> ^min <vmin> ^max <gy2> ^min-net <mn> ^max-net <nn> ^com <gx> ^commo <vcmo> ^compo <vcpo>) + (modify 5 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gy2> ^max <gy> ^com <gx> ^commo <vcmo> ^compo <vcpo>) + (modify 3 ^grid-y <gy2> ^came-from north) +) + +(p p251 + (context ^present lshape1) + (ff ^net-name <nn> ^grid-x 1 ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from west) + - (ff ^net-name <nn> ^grid-x 1 ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x <gx2> ^grid-y { <gy2> > <gy> }) + - (horizontal ^com { > <gy> < <gy2> }) + (vertical ^net-name nil ^min { <vmin> <= <gy> } ^max { <vmax> > <vmin> >= <gy2> } ^com 1 ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (pin ^pin-x 0 ^pin-y <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= 1 ^max >= 1 ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com 1 ^layer <lay>) + --> + (make vertical ^layer <lay> ^min <vmin> ^max <gy> ^min-net <mn> ^max-net <nn> ^com 1 ^commo <vcmo> ^compo <vcpo>) + (modify 4 ^min <gy2> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gy> ^max <gy2> ^com 1 ^commo <vcmo> ^compo <vcpo>) + (modify 2 ^grid-y <gy2> ^came-from south) +) + +(p p252 + (context ^present lshape1) + (ff ^net-name <nn> ^grid-x 1 ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from west) + - (ff ^net-name <nn> ^grid-x 1 ^pin-name <> <pn>) + (ff ^net-name <nn> ^grid-x <gx2> ^grid-y { <gy2> < <gy> }) + - (horizontal ^com { > <gy2> < <gy> }) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy> } ^com 1 ^layer <lay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (pin ^pin-x 0 ^pin-y <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min <= 1 ^max >= 1 ^com <gy2> ^layer <lay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com 1 ^layer <lay>) + --> + (make vertical ^layer <lay> ^min <vmin> ^max <gy2> ^min-net <mn> ^max-net <nn> ^com 1 ^commo <vcmo> ^compo <vcpo>) + (modify 4 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <lay> ^min <gy2> ^max <gy> ^com 1 ^commo <vcmo> ^compo <vcpo>) + (modify 2 ^grid-y <gy2> ^came-from north) +) + +(p p253 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> >= <gy1> > <vmin> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> >= <gx2> > <hmin> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p254 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p255 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p256 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy1>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p257 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + (ff ^net-name { <nn1> <> <nn> } ^grid-y <gy2> ^grid-x < <gx1>) + - (pin ^net-name <nn1> ^pin-x >= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p258 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + (ff ^net-name { <nn1> <> <nn> } ^grid-y <gy2> ^grid-x > <gx1>) + - (pin ^net-name <nn1> ^pin-x <= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p259 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + (ff ^net-name { <nn1> <> <nn> } ^grid-y <gy2> ^grid-x < <gx1>) + - (pin ^net-name <nn1> ^pin-x >= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p260 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx2>) + (ff ^net-name { <nn1> <> <nn> } ^grid-y <gy1> ^grid-x > <gx2>) + - (pin ^net-name <nn1> ^pin-x <= <gx2>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p261 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y < <gy2>) + - (pin ^net-name <nn1> ^pin-y >= <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p262 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y < <gy2>) + - (pin ^net-name <nn1> ^pin-y >= <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p263 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y > <gy2>) + - (pin ^net-name <nn1> ^pin-y <= <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p264 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy1>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx2> ^grid-y > <gy1>) + - (pin ^net-name <nn1> ^pin-y <= <gy1>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p265 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y < <gy2>) + - (pin ^net-name <nn1> ^pin-y >= <gy2>) + (ff ^net-name { <nn2> <> <nn> } ^grid-y <gy2> ^grid-x < <gx1>) + - (pin ^net-name <nn2> ^pin-x >= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p266 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y < <gy2>) + - (pin ^net-name <nn1> ^pin-y >= <gy2>) + (ff ^net-name { <nn2> <> <nn> } ^grid-y <gy2> ^grid-x > <gx1>) + - (pin ^net-name <nn2> ^pin-x <= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p267 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx1> ^grid-y > <gy2>) + - (pin ^net-name <nn1> ^pin-y <= <gy2>) + (ff ^net-name { <nn2> <> <nn> } ^grid-y <gy2> ^grid-x < <gx1>) + - (pin ^net-name <nn2> ^pin-x >= <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p268 + (context ^present lshape1) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + (ff ^net-name { <nn1> <> <nn> } ^grid-x <gx2> ^grid-y > <gy1>) + - (pin ^net-name <nn1> ^pin-y <= <gy1>) + (ff ^net-name { <nn2> <> <nn> } ^grid-y <gy1> ^grid-x > <gx2>) + - (pin ^net-name <nn2> ^pin-x <= <gx2>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p269 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p270 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p271 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p272 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx2>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p273 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p274 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p275 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p276 + (context ^present lshape2) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy1>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p277 + (context ^present lshape3) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p278 + (context ^present lshape3) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p279 + (context ^present lshape3) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <vlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <hlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p280 + (context ^present lshape3) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <hlay> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <vlay>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p281 + (context ^present lshape4) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <garb2>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p282 + (context ^present lshape4) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <garb2>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx2> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p283 + (context ^present lshape4) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> > <gy1> } ^grid-layer <garb2>) + (vertical ^net-name nil ^min { <vmin> <= <gy1> } ^max { <vmax> > <vmin> >= <gy2> } ^com <gx1> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy2> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx1>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy2>) + --> + (remove 1 3 4) + (make vertical ^com <gx1> ^layer <vlay> ^min <vmin> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy2> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <vlay> ^min <gy1> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy2> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p284 + (context ^present lshape4) + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <garb1> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <garb2>) + (vertical ^net-name nil ^min { <vmin> <= <gy2> } ^max { <vmax> > <vmin> >= <gy1> } ^com <gx2> ^layer <vlay> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn>) + (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com <gy1> ^layer <hlay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) + (vertical-layer <vlay>) + (horizontal-layer <hlay>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^max <= <vmin> ^com <gx2>) + - (vertical ^status nil ^net-name { <> <nn> <> nil } ^min >= <vmax> ^com <gx2>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^max <= <hmin> ^com <gy1>) + - (horizontal ^status nil ^net-name { <> <nn> <> nil } ^min >= <hmax> ^com <gy1>) + --> + (remove 1 3 4) + (make vertical ^com <gx2> ^layer <vlay> ^min <vmin> ^max <gy2> ^compo <vcpo> ^commo <vcmo> ^min-net <vnn> ^max-net <nn>) + (modify 5 ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <hmin> ^max <gx1> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify 6 ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <vlay> ^min <gy2> ^max <gy1> ^compo <vcpo> ^commo <vcmo> ^net-name <nn> ^pin-name <pn>) + (make horizontal ^com <gy1> ^layer <hlay> ^min <gx1> ^max <gx2> ^compo <hcpo> ^commo <hcmo> ^net-name <nn> ^pin-name <pn>) + (make context ^present check-for-routed-net) +) + +(p p285 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + - (ff ^grid-x <gx1> ^net-name <> <nn>) + { <v> (vertical ^net-name nil ^min { <vmin1> <= <gy1> } ^max { <vmax1> > <vmin1> >= <gy1> } ^com <gx1> ^layer <lay> ^commo <gx2> ^compo <cpo> ^min-net <vnn1>) } + { <h> (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com { <hcom> >= <vmin1> < <gy1> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (vertical-layer <lay>) + (ff ^grid-x <gx2> ^net-name <> <nn>) + - (horizontal ^net-name nil ^min <= <gx2> ^max >= <gx1> ^com { >= <vmin1> < <hcom> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx1>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx2>) + --> + (remove <c>) + (make vertical ^com <gx1> ^layer <lay> ^min <vmin1> ^max <hcom> ^compo <cpo> ^commo <gx2> ^min-net <vnn1> ^max-net <nn>) + (modify <v> ^min <gy1> ^min-net <nn>) + (make horizontal ^min <hmin> ^max <gx2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <lay> ^min <hcom> ^max <gy1> ^commo <gx2> ^compo <cpo> ^net-name <nn> ^pin-name <pn1>) + (make horizontal ^com <hcom> ^layer <lay> ^min <gx2> ^max <gx1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn1>) + (modify <ff> ^grid-x <gx2> ^grid-y <hcom> ^can-chng-layer nil ^came-from east) + (make context ^present check-for-routed-net) +) + +(p p286 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + - (ff ^grid-x <gx2> ^net-name <> <nn>) + { <v> (vertical ^net-name nil ^min { <vmin1> <= <gy2> } ^max { <vmax1> > <vmin1> >= <gy2> } ^com <gx2> ^layer <lay> ^commo <cmo> ^compo <gx1> ^max-net <vnn1>) } + { <h> (horizontal ^net-name nil ^min { <hmin> <= <gx2> } ^max { <hmax> > <hmin> >= <gx1> } ^com { <hcom> <= <vmax1> > <gy2> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (vertical-layer <lay>) + (ff ^grid-x <gx1> ^net-name <> <nn>) + - (horizontal ^net-name nil ^min <= <gx2> ^max >= <gx1> ^com { <= <vmax1> > <hcom> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx2>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx1>) + --> + (remove <c>) + (make vertical ^com <gx2> ^layer <lay> ^min <hcom> ^max <vmax1> ^compo <gx1> ^commo <cmo> ^max-net <vnn1> ^min-net <nn>) + (modify <v> ^max <gy2> ^max-net <nn>) + (make horizontal ^min <hmin> ^max <gx2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gx1> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <lay> ^max <hcom> ^min <gy2> ^commo <cmo> ^compo <gx1> ^net-name <nn> ^pin-name <pn2>) + (make horizontal ^com <hcom> ^layer <lay> ^min <gx2> ^max <gx1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn2>) + (modify <ff> ^grid-x <gx1> ^grid-y <hcom> ^can-chng-layer nil ^came-from west) + (make context ^present check-for-routed-net) +) + +(p p287 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + - (ff ^grid-x <gx1> ^net-name <> <nn>) + { <v> (vertical ^net-name nil ^min { <vmin1> <= <gy1> } ^max { <vmax1> > <vmin1> >= <gy1> } ^com <gx1> ^layer <lay> ^commo <cmo> ^compo <gx2> ^min-net <vnn1>) } + { <h> (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com { <hcom> >= <vmin1> < <gy1> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (vertical-layer <lay>) + (ff ^grid-x <gx2> ^net-name <> <nn>) + - (horizontal ^net-name nil ^min <= <gx1> ^max >= <gx2> ^com { >= <vmin1> < <hcom> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx1>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx2>) + --> + (remove <c>) + (make vertical ^com <gx1> ^layer <lay> ^min <vmin1> ^max <hcom> ^compo <gx2> ^commo <cmo> ^min-net <vnn1> ^max-net <nn>) + (modify <v> ^min <gy1> ^min-net <nn>) + (make horizontal ^min <hmin> ^max <gx1> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx1> ^layer <lay> ^min <hcom> ^max <gy1> ^commo <cmo> ^compo <gx2> ^net-name <nn> ^pin-name <pn1>) + (make horizontal ^com <hcom> ^layer <lay> ^min <gx1> ^max <gx2> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn1>) + (modify <ff> ^grid-x <gx2> ^grid-y <hcom> ^can-chng-layer nil ^came-from west) + (make context ^present check-for-routed-net) +) + +(p p288 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + - (ff ^grid-x <gx2> ^net-name <> <nn>) + { <v> (vertical ^net-name nil ^min { <vmin1> <= <gy2> } ^max { <vmax1> > <vmin1> >= <gy2> } ^com <gx2> ^layer <lay> ^commo <gx1> ^compo <cpo> ^max-net <vnn1>) } + { <h> (horizontal ^net-name nil ^min { <hmin> <= <gx1> } ^max { <hmax> > <hmin> >= <gx2> } ^com { <hcom> <= <vmax1> > <gy2> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (vertical-layer <lay>) + (ff ^grid-x <gx1> ^net-name <> <nn>) + - (horizontal ^net-name nil ^min <= <gx1> ^max >= <gx2> ^com { <= <vmax1> > <hcom> } ^layer <lay>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx2> ^max >= <gx2> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx2>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <gx1> ^max >= <gx1> ^com <hcom>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gx1>) + --> + (remove <c>) + (make vertical ^com <gx2> ^layer <lay> ^min <hcom> ^max <vmax1> ^compo <cpo> ^commo <gx1> ^max-net <vnn1> ^min-net <nn>) + (modify <v> ^max <gy2> ^max-net <nn>) + (make horizontal ^min <hmin> ^max <gx1> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gx2> ^min-net <nn>) + (make vertical ^com <gx2> ^layer <lay> ^max <hcom> ^min <gy2> ^commo <gx1> ^compo <cpo> ^net-name <nn> ^pin-name <pn2>) + (make horizontal ^com <hcom> ^layer <lay> ^min <gx1> ^max <gx2> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn2>) + (modify <ff> ^grid-x <gx1> ^grid-y <hcom> ^can-chng-layer nil ^came-from east) + (make context ^present check-for-routed-net) +) + +(p p289 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + - (ff ^grid-y <gy1> ^net-name <> <nn>) + { <v> (horizontal ^net-name nil ^min { <vmin1> <= <gx1> } ^max { <vmax1> > <vmin1> >= <gx1> } ^com <gy1> ^layer <lay> ^commo <gy2> ^compo <cpo> ^min-net <vnn1>) } + { <h> (vertical ^net-name nil ^min { <hmin> <= <gy2> } ^max { <hmax> > <hmin> >= <gy1> } ^com { <hcom> >= <vmin1> < <gx1> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (horizontal-layer <lay>) + (ff ^grid-y <gy2> ^net-name <> <nn>) + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com { >= <vmin1> < <hcom> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy1>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy2>) + --> + (remove <c>) + (make horizontal ^com <gy1> ^layer <lay> ^min <vmin1> ^max <hcom> ^compo <cpo> ^commo <gy2> ^min-net <vnn1> ^max-net <nn>) + (modify <v> ^min <gx1> ^min-net <nn>) + (make vertical ^min <hmin> ^max <gy2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <lay> ^min <hcom> ^max <gx1> ^commo <gy2> ^compo <cpo> ^net-name <nn> ^pin-name <pn1>) + (make vertical ^com <hcom> ^layer <lay> ^min <gy2> ^max <gy1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn1>) + (modify <ff> ^grid-y <gy2> ^grid-x <hcom> ^can-chng-layer nil ^came-from north) + (make context ^present check-for-routed-net) +) + +(p p290 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> < <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + - (ff ^grid-y <gy2> ^net-name <> <nn>) + { <v> (horizontal ^net-name nil ^min { <vmin1> <= <gx2> } ^max { <vmax1> > <vmin1> >= <gx2> } ^com <gy2> ^layer <lay> ^commo <cmo> ^compo <gy1> ^max-net <vnn1>) } + { <h> (vertical ^net-name nil ^min { <hmin> <= <gy2> } ^max { <hmax> > <hmin> >= <gy1> } ^com { <hcom> <= <vmax1> > <gx2> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (horizontal-layer <lay>) + (ff ^grid-y <gy1> ^net-name <> <nn>) + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com { <= <vmax1> > <hcom> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy2>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy1>) + --> + (remove <c>) + (make horizontal ^com <gy2> ^layer <lay> ^min <hcom> ^max <vmax1> ^compo <gy1> ^commo <cmo> ^max-net <vnn1> ^min-net <nn>) + (modify <v> ^max <gx2> ^max-net <nn>) + (make vertical ^min <hmin> ^max <gy2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <lay> ^max <hcom> ^min <gx2> ^commo <cmo> ^compo <gy1> ^net-name <nn> ^pin-name <pn2>) + (make vertical ^com <hcom> ^layer <lay> ^min <gy2> ^max <gy1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn2>) + (modify <ff> ^grid-y <gy1> ^grid-x <hcom> ^can-chng-layer nil ^came-from south) + (make context ^present check-for-routed-net) +) + +(p p291 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + { <ff> (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) } + (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) + - (ff ^grid-y <gy1> ^net-name <> <nn>) + { <v> (horizontal ^net-name nil ^min { <vmin1> <= <gx1> } ^max { <vmax1> > <vmin1> >= <gx1> } ^com <gy1> ^layer <lay> ^commo <gy2> ^compo <cpo> ^max-net <vnn1>) } + { <h> (vertical ^net-name nil ^min { <hmin> <= <gy2> } ^max { <hmax> > <hmin> >= <gy1> } ^com { <hcom> <= <vmax1> > <gx1> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (horizontal-layer <lay>) + (ff ^grid-y <gy2> ^net-name <> <nn>) + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com { <= <vmax1> > <hcom> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy1>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy2>) + --> + (remove <c>) + (make horizontal ^com <gy1> ^layer <lay> ^min <hcom> ^max <vmax1> ^compo <cpo> ^commo <gy2> ^max-net <vnn1> ^min-net <nn>) + (modify <v> ^max <gx1> ^max-net <nn>) + (make vertical ^min <hmin> ^max <gy2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy1> ^layer <lay> ^min <gx1> ^max <hcom> ^commo <gy2> ^compo <cpo> ^net-name <nn> ^pin-name <pn1>) + (make vertical ^com <hcom> ^layer <lay> ^min <gy2> ^max <gy1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn1>) + (modify <ff> ^grid-y <gy2> ^grid-x <hcom> ^can-chng-layer nil ^came-from north) + (make context ^present check-for-routed-net) +) + +(p p292 + { <c> (context ^present lshape1) } + (net ^net-name <nn> ^net-no-of-pins 2 ^net-is-routed <> yes) + (ff ^net-name <nn> ^grid-x <gx1> ^grid-y <gy1> ^grid-layer <lay> ^pin-name <pn1>) + { <ff> (ff ^net-name <nn> ^grid-x { <gx2> > <gx1> } ^grid-y { <gy2> < <gy1> } ^grid-layer <lay> ^pin-name <pn2>) } + - (ff ^grid-y <gy2> ^net-name <> <nn>) + { <v> (horizontal ^net-name nil ^min { <vmin1> <= <gx2> } ^max { <vmax1> > <vmin1> >= <gx2> } ^com <gy2> ^layer <lay> ^commo <cmo> ^compo <gy1> ^min-net <vnn1>) } + { <h> (vertical ^net-name nil ^min { <hmin> <= <gy2> } ^max { <hmax> > <hmin> >= <gy1> } ^com { <hcom> >= <vmin1> < <gx2> } ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn>) } + (horizontal-layer <lay>) + (ff ^grid-y <gy1> ^net-name <> <nn>) + - (vertical ^net-name nil ^min <= <gy2> ^max >= <gy1> ^com { >= <vmin1> < <hcom> } ^layer <lay>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy2> ^max >= <gy2> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy2>) + - (vertical ^net-name { <> <nn> <> nil } ^min <= <gy1> ^max >= <gy1> ^com <hcom>) + - (horizontal ^net-name { <> <nn> <> nil } ^min <= <hcom> ^max >= <hcom> ^com <gy1>) + --> + (remove <c>) + (make horizontal ^com <gy2> ^layer <lay> ^min <vmin1> ^max <hcom> ^compo <gy1> ^commo <cmo> ^min-net <vnn1> ^max-net <nn>) + (modify <v> ^min <gx2> ^min-net <nn>) + (make vertical ^min <hmin> ^max <gy2> ^com <hcom> ^layer <lay> ^compo <hcpo> ^commo <hcmo> ^min-net <hnn> ^max-net <nn>) + (modify <h> ^min <gy1> ^min-net <nn>) + (make horizontal ^com <gy2> ^layer <lay> ^max <gx2> ^min <hcom> ^commo <cmo> ^compo <gy1> ^net-name <nn> ^pin-name <pn2>) + (make vertical ^com <hcom> ^layer <lay> ^min <gy2> ^max <gy1> ^commo <hcmo> ^compo <hcpo> ^net-name <nn> ^pin-name <pn2>) + (modify <ff> ^grid-y <gy1> ^grid-x <hcom> ^can-chng-layer nil ^came-from south) + (make context ^present check-for-routed-net) +) + +(p p211 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> west ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx> }) + (horizontal ^net-name nil ^min { <min> <= <gx2> } ^max { <max> >= <gx> > <min> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <gx> ^max >= <gx>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x >= <gx> ^grid-y < <gy>) + - (ff ^net-name <nn> ^grid-x >= <gx> ^grid-y > <gy>) + --> + (make horizontal ^min <min> ^max (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min <gx> ^min-net <nn>) + (make horizontal ^max <gx> ^min (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> - 1) ^came-from east ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p212 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> south ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> < <gy> }) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { <max> > <min> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x < <gx> ^grid-y >= <gy>) + - (ff ^net-name <nn> ^grid-x > <gx> ^grid-y >= <gy>) + --> + (make vertical ^min <min> ^max (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min <gy> ^min-net <nn>) + (make vertical ^max <gy> ^min (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> - 1) ^came-from north ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p213 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> east ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> }) + (horizontal ^net-name nil ^min { <min> <= <gx> } ^max { <max> > <min> >= <gx2> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max > <gx>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <= <gx> ^grid-y < <gy>) + - (ff ^net-name <nn> ^grid-x <= <gx> ^grid-y > <gy>) + --> + (make horizontal ^max <max> ^min (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max <gx> ^max-net <nn>) + (make horizontal ^min <gx> ^max (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> + 1) ^came-from west ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p214 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> north ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy> }) + (vertical ^net-name nil ^min { <min> <= <gy> } ^max { <max> > <min> >= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x < <gx> ^grid-y <= <gy>) + - (ff ^net-name <nn> ^grid-x > <gx> ^grid-y <= <gy>) + --> + (make vertical ^max <max> ^min (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max <gy> ^max-net <nn>) + (make vertical ^min <gy> ^max (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> + 1) ^came-from south ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p215 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> west ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx> } ^grid-y <= <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx2> } ^max { <max> > <min> >= <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <gx> ^max >= <gx>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y > <gy>) + --> + (make horizontal ^min <min> ^max (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min <gx> ^min-net <nn>) + (make horizontal ^max <gx> ^min (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> - 1) ^came-from east ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p216 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> west ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> < <gx> } ^grid-y >= <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx2> } ^max { <max> > <min> >= <gx> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <gx> ^max >= <gx>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y < <gy>) + --> + (make horizontal ^min <min> ^max (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min <gx> ^min-net <nn>) + (make horizontal ^max <gx> ^min (compute <gx> - 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> - 1) ^came-from east ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p217 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> east ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> } ^grid-y <= <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx> } ^max { <max> > <min> >= <gx2> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max > <gx>) + - (vertical ^net-name nil ^min < <gy> ^max >= <gy> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y > <gy>) + --> + (make horizontal ^max <max> ^min (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max <gx> ^max-net <nn>) + (make horizontal ^min <gx> ^max (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> + 1) ^came-from west ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p218 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> east ^can-chng-layer no) + (ff ^net-name <nn> ^grid-x { <gx2> > <gx> } ^grid-y >= <gy>) + (horizontal ^net-name nil ^min { <min> <= <gx> } ^max { <max> > <min> >= <gx2> } ^com <gy> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max > <gx>) + - (vertical ^net-name nil ^min <= <gy> ^max > <gy> ^com <gx> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y < <gy>) + --> + (make horizontal ^max <max> ^min (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max <gx> ^max-net <nn>) + (make horizontal ^min <gx> ^max (compute <gx> + 1) ^com <gy> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-x (compute <gx> + 1) ^came-from west ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p219 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> north ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy> } ^grid-x >= <gx>) + (vertical ^net-name nil ^min { <min> <= <gy> } ^max { <max> > <min> >= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <vnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <lay>) + - (ff ^net-name <nn> ^grid-x < <gx>) + --> + (make vertical ^max <max> ^min (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <vnn> ^min-net <nn>) + (modify 4 ^max <gy> ^max-net <nn>) + (make vertical ^min <gy> ^max (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> + 1) ^came-from south ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p220 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> north ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> > <gy> } ^grid-x <= <gx>) + (vertical ^net-name nil ^min { <min> <= <gy> } ^max { <max> > <min> >= <gy2> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <vnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (ff ^net-name <nn> ^grid-x > <gx>) + --> + (make vertical ^max <max> ^min (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <vnn> ^min-net <nn>) + (modify 4 ^max <gy> ^max-net <nn>) + (make vertical ^min <gy> ^max (compute <gy> + 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> + 1) ^came-from south ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p221 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> south ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> < <gy> } ^grid-x <= <gx>) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { <max> > <min> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <vnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy>) + - (horizontal ^net-name nil ^min < <gx> ^max >= <gx> ^com <gy> ^layer <lay>) + - (ff ^net-name <nn> ^grid-x > <gx>) + --> + (make vertical ^min <min> ^max (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <vnn> ^min-net <nn>) + (modify 4 ^min <gy> ^min-net <nn>) + (make vertical ^max <gy> ^min (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> - 1) ^came-from north ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p222 + (context ^present loose-constraint) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from <> north ^can-chng-layer no) + (ff ^net-name <nn> ^grid-y { <gy2> < <gy> } ^grid-x >= <gx>) + (vertical ^net-name nil ^min { <min> <= <gy2> } ^max { <max> > <min> >= <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <vnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max > <gx> ^com <gy> ^layer <lay>) + - (ff ^net-name <nn> ^grid-x < <gx>) + --> + (make vertical ^min <min> ^max (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^max-net <vnn> ^min-net <nn>) + (modify 4 ^min <gy> ^min-net <nn>) + (make vertical ^max <gy> ^min (compute <gy> - 1) ^com <gx> ^layer <lay> ^commo <cmo> ^compo <cpo> ^net-name <nn> ^pin-name <pn>) + (modify 2 ^grid-y (compute <gy> - 1) ^came-from north ^can-chng-layer nil) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p223 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gx2> } ^com { <com2> >= <min1> <= <max1> >= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + --> + (make horizontal ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make horizontal ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> + 1) ^grid-y <com2> ^grid-layer <lay> ^came-from west) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p224 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-y { <gy2> > <com1> } ^grid-x <gx>) + (vertical ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gy2> } ^com { <com2> >= <min1> <= <max1> >= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + --> + (make vertical ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make vertical ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> + 1) ^grid-x <com2> ^grid-layer <lay> ^came-from south) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p225 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <gx2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> >= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^max-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + --> + (make horizontal ^max <max2> ^min <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make horizontal ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> - 1) ^grid-y <com2> ^grid-layer <lay> ^came-from east) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p226 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-y { <gy2> < <com1> } ^grid-x <gx>) + (vertical ^net-name nil ^min { <min2> <= <gy2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> >= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^max-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + --> + (make vertical ^max <max2> ^min <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make vertical ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> - 1) ^grid-x <com2> ^grid-layer <lay> ^came-from north) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p227 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gx2> } ^com { <com2> >= <min1> <= <max1> <= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + --> + (make horizontal ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make horizontal ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> + 1) ^grid-y <com2> ^grid-layer <lay> ^came-from west) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p228 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-y { <gy2> > <com1> } ^grid-x <gx>) + (vertical ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gy2> } ^com { <com2> >= <min1> <= <max1> <= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + --> + (make vertical ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make vertical ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> + 1) ^grid-x <com2> ^grid-layer <lay> ^came-from south) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p229 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <gx2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> <= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^max-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^layer <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + --> + (make horizontal ^max <max2> ^min <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make horizontal ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> - 1) ^grid-y <com2> ^grid-layer <lay> ^came-from east) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p230 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy2> < <com1> }) + (vertical ^net-name nil ^min { <min2> <= <gy2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> <= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^max-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^layer <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + --> + (make vertical ^max <max2> ^min <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^max-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make vertical ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> - 1) ^grid-x <com2> ^grid-layer <lay> ^came-from north) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p231 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gx2> } ^com { <com2> >= <min1> <= <max1> >= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (vertical ^net-name nil ^max <min1> ^com <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make horizontal ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make horizontal ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> + 1) ^grid-y <com2> ^grid-layer <lay> ^came-from west) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p232 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> > <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gx2> } ^com { <com2> >= <min1> <= <max1> <= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (vertical ^net-name nil ^max <min1> ^com <com1>) + - (horizontal ^net-name nil ^min <= <com1> ^max > <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make horizontal ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make horizontal ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> + 1) ^grid-y <com2> ^grid-layer <lay> ^came-from west) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p233 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <gx2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> >= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (vertical ^net-name nil ^max <min1> ^com <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make horizontal ^min <com1> ^max <max2> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make horizontal ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> - 1) ^grid-y <com2> ^grid-layer <lay> ^came-from east) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p234 + (context ^present loose-constraint) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x { <gx2> < <com1> } ^grid-y <gy>) + (horizontal ^net-name nil ^min { <min2> <= <gx2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> <= <gy> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (vertical ^net-name nil ^max <min1> ^com <com1>) + - (horizontal ^net-name nil ^min < <com1> ^max >= <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-x <com1>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make horizontal ^min <com1> ^max <max2> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make horizontal ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-x (compute <com1> - 1) ^grid-y <com2> ^grid-layer <lay> ^came-from east) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p235 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy2> > <com1> }) + (vertical ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gy2> } ^com { <com2> >= <min1> <= <max1> >= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (horizontal ^net-name nil ^max <min1> ^com <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make vertical ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make vertical ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> + 1) ^grid-x <com2> ^grid-layer <lay> ^came-from south) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p236 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy2> > <com1> }) + (vertical ^net-name nil ^min { <min2> <= <com1> } ^max { <max2> > <min2> >= <gy2> } ^com { <com2> >= <min1> <= <max1> <= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <com1> ^max > <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (horizontal ^net-name nil ^max <min1> ^com <com1>) + - (vertical ^net-name nil ^min <= <com1> ^max > <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make vertical ^min <min2> ^max <com1> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^max-net <nn>) + (modify 4 ^min (compute <com1> + 1) ^min-net <nn>) + (make vertical ^min <com1> ^max (compute <com1> + 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> + 1) ^grid-x <com2> ^grid-layer <lay> ^came-from south) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p237 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy2> < <com1> }) + (vertical ^net-name nil ^min { <min2> <= <gy2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> >= <gx> } ^layer <lay> ^compo <cpo2> ^commo <cmo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com { < <com2> >= <min1> } ^layer <lay>) + - (horizontal ^net-name nil ^max <min1> ^com <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make vertical ^min <com1> ^max <max2> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make vertical ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> - 1) ^grid-x <com2> ^grid-layer <lay> ^came-from north) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p238 + (context ^present loose-constraint) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <min1> ^max <max1> ^com <com1> ^layer <lay> ^compo <garb1> ^commo <garb2> ^pin-name <pn>) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y { <gy2> < <com1> }) + (vertical ^net-name nil ^min { <min2> <= <gy2> } ^max { <max2> > <min2> >= <com1> } ^com { <com2> >= <min1> <= <max1> <= <gx> } ^layer <lay> ^commo <cmo2> ^compo <cpo2> ^min-net <hnn>) + - (vertical ^status nil ^net-name { <nn> <> nil } ^min < <com1> ^max >= <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com { > <com2> <= <max1> } ^layer <lay>) + - (horizontal ^net-name nil ^max <min1> ^com <com1>) + - (vertical ^net-name nil ^min < <com1> ^max >= <com1> ^com <com2> ^layer <> <lay>) + - (ff ^net-name <nn> ^grid-y <com1>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^max <min1> ^com <com1> ^layer <lay>) + --> + (make vertical ^min <com1> ^max <max2> ^commo <cmo2> ^compo <cpo2> ^layer <lay> ^com <com2> ^min-net <hnn> ^min-net <nn>) + (modify 4 ^max (compute <com1> - 1) ^max-net <nn>) + (make vertical ^max <com1> ^min (compute <com1> - 1) ^com <com2> ^layer <lay> ^net-name <nn> ^pin-name <pn> ^commo <cmo2> ^compo <cpo2>) + (make ff ^net-name <nn> ^pin-name <pn> ^grid-y (compute <com1> - 1) ^grid-x <com2> ^grid-layer <lay> ^came-from north) + (remove 1) + (make context ^present propagate-constraint) +) + +(p p239 + (context ^present loose-constraint0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side top) + (vertical ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy> ^com { <vcom> > <gx> } ^layer <garb1> ^compo <garb2> ^commo <garb3> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-y > <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <vcom> ^com <gy>) + (vertical ^net-name nil ^min { <min> < <gy> } ^max >= <gy> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <mn>) + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <gy> ^como <hcmo>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <hcmo> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <hcmo> ^can-chng-layer nil) + (modify 1 ^present propagate-constraint) +) + +(p p240 + (context ^present loose-constraint0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from north) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side top) + (vertical ^net-name { <nn> <> nil } ^min < <gy> ^max >= <gy> ^com { <vcom> < <gx> } ^layer <garb1> ^compo <garb2> ^commo <garb3> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-y > <gy>) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcom> ^max >= <gx> ^com <gy>) + (vertical ^net-name nil ^min { <min> < <gy> } ^max >= <gy> ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^min-net <mn>) + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <gy> ^como <hcmo>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <hcmo> ^min <min> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^min-net <mn> ^max-net <nn>) + (modify 5 ^min <gy> ^min-net <nn>) + (make vertical ^net-name <nn> ^max <gy> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <hcmo> ^can-chng-layer nil) + (modify 1 ^present propagate-constraint) +) + +(p p241 + (context ^present loose-constraint0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from south) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side bottom) + (vertical ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy> ^com { <vcom> > <gx> } ^layer <garb1> ^compo <garb2> ^commo <garb3> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-y < <gy>) + - (horizontal ^net-name nil ^min <= <gx> ^max >= <vcom> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <gx> ^max >= <vcom> ^com <gy>) + (vertical ^net-name nil ^min <= <gy> ^max { <max> > <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <hcmo> ^como <gy>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <max> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^max-net <mn> ^min-net <nn>) + (modify 5 ^max <gy> ^max-net <nn>) + (make vertical ^net-name <nn> ^min <gy> ^max <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <hcmo> ^can-chng-layer nil) + (modify 1 ^present propagate-constraint) +) + +(p p242 + (context ^present loose-constraint0) + (ff ^net-name <nn> ^grid-x <gx> ^grid-y <gy> ^grid-layer <lay> ^pin-name <pn> ^came-from south) + (pin ^net-name <nn> ^pin-name <pn> ^pin-channel-side bottom) + (vertical ^net-name { <nn> <> nil } ^min <= <gy> ^max > <gy> ^com { <vcom> < <gx> } ^layer <garb1> ^compo <garb2> ^commo <garb3> ^pin-name <> <pn>) + - (ff ^net-name <nn> ^grid-y < <gy>) + - (horizontal ^net-name nil ^min <= <vcom> ^max >= <gx> ^com <gy>) + - (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcom> ^max >= <gx> ^com <gy>) + (vertical ^net-name nil ^min <= <gy> ^max { <max> > <gy> } ^com <gx> ^layer <lay> ^compo <cpo> ^commo <cmo> ^max-net <mn>) + - (horizontal ^net-name { <> nil <> <nn> } ^min <= <gx> ^max >= <gx> ^layer <lay> ^compo <gy>) + (congestion ^direction row ^coordinate <hcmo> ^como <gy>) + - (vertical ^status nil ^net-name { <> nil <> <nn> } ^min <= <hcmo> ^max >= <hcmo> ^com <gx> ^layer <lay>) + --> + (make vertical ^net-name nil ^max <max> ^min <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^max-net <mn> ^min-net <nn>) + (modify 5 ^max <gy> ^max-net <nn>) + (make vertical ^net-name <nn> ^min <gy> ^max <hcmo> ^layer <lay> ^com <gx> ^commo <cmo> ^compo <cpo> ^pin-name <pn>) + (modify 2 ^grid-y <hcmo> ^can-chng-layer nil) + (modify 1 ^present propagate-constraint) +) + +(p p243 + (context ^present loose-constraint0) + --> + (modify 1 ^present loose-constraint) +) + +(p p363 + (move-via <nn>) + --> + (remove 1) + (make finally-routed <nn>) +) + +(p p364 + (move-via <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay> ^compo <garb1> ^commo <hcmo> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <hcmo> ^max <hcom> ^com { <vcom> >= <hmin> <= <hmax> } ^layer { <vlay> <> <hlay> }) + (vertical ^net-name nil ^min { <vmin2> <= <hcmo> } ^max { <vmax2> > <vmin2> >= <hcom> } ^com <vcom> ^layer <hlay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (horizontal ^net-name <> <nn> ^min < <vcom> ^max >= <vcom> ^com <hcmo>) + - (vertical ^net-name <> <nn> ^min < <hcmo> ^max <hcmo> ^com <vcom>) + --> + (modify 3 ^max <hcmo>) + (make vertical ^layer <vlay> ^max <hcom> ^min <hcmo> ^com <vcom> ^min-net <nn> ^commo <vcmo> ^compo <vcpo>) + (make vertical ^layer <hlay> ^min <vmin2> ^max <hcmo> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn> ^com <vcom>) + (modify 4 ^min <hcom> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <hlay> ^min <hcmo> ^max <hcom> ^commo <vcmo> ^compo <vcpo> ^com <vcom>) + (remove 1) + (make move-via <nn> <vlay> <vcom> <hcom>) +) + +(p p365 + (move-via <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay> ^compo <garb1> ^commo <hcmo> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <= <hcmo> ^max <hcom> ^com { <vcom> >= <hmin> <= <hmax> } ^layer { <vlay> <> <hlay> }) + (vertical ^net-name nil ^min { <vmin2> <= <hcmo> } ^max { <vmax2> > <vmin2> >= <hcom> } ^com <vcom> ^layer <hlay> ^compo <vcpo> ^commo <vcmo> ^min-net <mn>) + - (horizontal ^net-name <> <nn> ^min <= <vcom> ^max > <vcom> ^com <hcmo>) + - (vertical ^net-name <> <nn> ^min < <hcmo> ^max <hcmo> ^com <vcom>) + --> + (modify 3 ^max <hcmo>) + (make vertical ^layer <vlay> ^max <hcom> ^min <hcmo> ^com <vcom> ^min-net <nn> ^commo <vcmo> ^compo <vcpo>) + (make vertical ^layer <hlay> ^min <vmin2> ^max <hcmo> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn> ^com <vcom>) + (modify 4 ^min <hcom> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <hlay> ^min <hcmo> ^max <hcom> ^commo <vcmo> ^compo <vcpo> ^com <vcom>) + (remove 1) + (make move-via <nn> <vlay> <vcom> <hcom>) +) + +(p p366 + (move-via <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay> ^compo <garb1> ^commo <vcmo> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcmo> ^max <vcom> ^com { <hcom> >= <vmin> <= <vmax> } ^layer { <hlay> <> <vlay> }) + (horizontal ^net-name nil ^min { <hmin2> <= <vcmo> } ^max { <hmax2> > <hmin2> >= <vcom> } ^com <hcom> ^layer <vlay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (vertical ^net-name <> <nn> ^min < <hcom> ^max >= <hcom> ^com <vcmo>) + - (horizontal ^net-name <> <nn> ^min < <vcmo> ^max <vcmo> ^com <hcom>) + --> + (modify 3 ^max <vcmo>) + (make horizontal ^layer <hlay> ^max <vcom> ^min <vcmo> ^com <hcom> ^min-net <nn> ^commo <hcmo> ^compo <hcpo>) + (make horizontal ^layer <vlay> ^min <hmin2> ^max <vcmo> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn> ^com <hcom>) + (modify 4 ^min <vcom> ^min-net <nn>) + (make horizotnal ^net-name <nn> ^pin-name <pn> ^layer <vlay> ^min <vcmo> ^max <vcom> ^commo <hcmo> ^compo <hcpo> ^com <hcom>) + (remove 1) + (make move-via <nn> <hlay> <hcom> <vcom>) +) + +(p p367 + (move-via <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay> ^compo <garb1> ^commo <vcmo> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <= <vcmo> ^com { <hcom> >= <vmin> <= <vmax> } ^max <vcom> ^layer { <hlay> <> <vlay> }) + (horizontal ^net-name nil ^min { <hmin2> <= <vcmo> } ^max { <hmax2> > <hmin2> >= <vcom> } ^com <hcom> ^layer <vlay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (vertical ^net-name <> <nn> ^min <= <hcom> ^max > <hcom> ^com <vcmo>) + - (horizontal ^net-name <> <nn> ^min < <vcmo> ^max <vcmo> ^com <hcom>) + --> + (modify 3 ^max <vcmo>) + (make horizontal ^layer <hlay> ^max <vcom> ^min <vcmo> ^com <hcom> ^min-net <nn> ^commo <hcmo> ^compo <hcpo>) + (make horizontal ^layer <vlay> ^min <hmin2> ^max <vcmo> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn> ^com <hcom>) + (modify 4 ^min <vcom> ^min-net <nn>) + (make horizotnal ^net-name <nn> ^pin-name <pn> ^layer <vlay> ^min <vcmo> ^max <vcom> ^commo <hcmo> ^compo <hcpo> ^com <hcom>) + (remove 1) + (make move-via <nn> <hlay> <hcom> <vcom>) +) + +(p p368 + (move-via <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay> ^compo <hcpo> ^commo <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <hcom> ^max >= <hcpo> ^com { <vcom> >= <hmin> <= <hmax> } ^layer { <vlay> <> <hlay> }) + (vertical ^net-name nil ^min { <vmin2> <= <hcom> } ^max { <vmax2> > <vmin2> >= <hcpo> } ^com <vcom> ^layer <hlay> ^commo <vcmo> ^compo <vcpo> ^min-net <mn>) + - (horizontal ^net-name <> <nn> ^min < <vcom> ^max >= <vcom> ^com <hcpo>) + - (vertical ^net-name <> <nn> ^min <hcpo> ^max > <hcpo> ^com <vcom>) + --> + (modify 3 ^min <hcpo>) + (make vertical ^layer <vlay> ^min <hcom> ^max <hcpo> ^com <vcom> ^max-net <nn> ^commo <vcmo> ^compo <vcpo>) + (make vertical ^layer <hlay> ^min <vmin2> ^max <hcom> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn> ^com <vcom>) + (modify 4 ^min <hcpo> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <hlay> ^min <hcom> ^max <hcpo> ^commo <vcmo> ^compo <vcpo> ^com <vcom>) + (remove 1) + (make move-via <nn> <vlay> <vcom> <hcom>) +) + +(p p369 + (move-via <nn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <hmin> ^max <hmax> ^com <hcom> ^layer <hlay> ^compo <hcpo> ^commo <garb1> ^pin-name <pn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <hcom> ^max >= <hcpo> ^com { <vcom> >= <hmin> <= <hmax> } ^layer { <vlay> <> <hlay> }) + (vertical ^net-name nil ^min { <vmin2> <= <hcom> } ^max { <vmax2> > <vmin2> >= <hcpo> } ^com <vcom> ^layer <hlay> ^commo <vcmo> ^compo <vcpo> ^min-net <mn>) + - (horizontal ^net-name <> <nn> ^min <= <vcom> ^max > <vcom> ^com <hcpo>) + - (vertical ^net-name <> <nn> ^min <hcpo> ^max > <hcpo> ^com <vcom>) + --> + (modify 3 ^min <hcpo>) + (make vertical ^layer <vlay> ^min <hcom> ^max <hcpo> ^com <vcom> ^max-net <nn> ^commo <vcmo> ^compo <vcpo>) + (make vertical ^layer <hlay> ^min <vmin2> ^max <hcom> ^commo <vcmo> ^compo <vcpo> ^min-net <mn> ^max-net <nn> ^com <vcom>) + (modify 4 ^min <hcpo> ^min-net <nn>) + (make vertical ^net-name <nn> ^pin-name <pn> ^layer <hlay> ^min <hcom> ^max <hcpo> ^commo <vcmo> ^compo <vcpo> ^com <vcom>) + (remove 1) + (make move-via <nn> <vlay> <vcom> <hcom>) +) + +(p p370 + (move-via <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay> ^compo <vcpo> ^commo <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <vcom> ^max >= <vcpo> ^com { <hcom> >= <vmin> <= <vmax> } ^layer { <hlay> <> <vlay> }) + (horizontal ^net-name nil ^min { <hmin2> <= <vcom> } ^max { <hmax2> > <hmin2> >= <vcpo> } ^com <hcom> ^layer <vlay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (vertical ^net-name <> <nn> ^min < <hcom> ^max >= <hcom> ^com <vcpo>) + - (horizontal ^net-name <> <nn> ^min <vcpo> ^max > <vcpo> ^com <hcom>) + --> + (modify 3 ^min <vcpo>) + (make horizontal ^layer <hlay> ^max <vcpo> ^min <vcom> ^com <hcom> ^max-net <nn> ^commo <hcmo> ^compo <hcpo>) + (make horizontal ^layer <vlay> ^min <hmin2> ^max <vcom> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn> ^com <hcom>) + (modify 4 ^min <vcpo> ^min-net <nn>) + (make horizotnal ^net-name <nn> ^pin-name <pn> ^layer <vlay> ^min <vcom> ^max <vcpo> ^commo <hcmo> ^compo <hcpo> ^com <hcom>) + (remove 1) + (make move-via <nn> <hlay> <hcom> <vcom>) +) + +(p p371 + (move-via <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin> ^max <vmax> ^com <vcom> ^layer <vlay> ^compo <vcpo> ^commo <garb1> ^pin-name <pn>) + (horizontal ^status nil ^net-name { <nn> <> nil } ^min <vcom> ^max >= <vcpo> ^com { <hcom> >= <vmin> <= <vmax> } ^layer { <hlay> <> <vlay> }) + (horizontal ^net-name nil ^min { <hmin2> <= <vcom> } ^max { <hmax2> > <hmin2> >= <vcpo> } ^com <hcom> ^layer <vlay> ^compo <hcpo> ^commo <hcmo> ^min-net <mn>) + - (vertical ^net-name <> <nn> ^min <= <hcom> ^max > <hcom> ^com <vcmo>) + - (horizontal ^net-name <> <nn> ^min <vcpo> ^max > <vcpo> ^com <hcom>) + --> + (modify 3 ^min <vcpo>) + (make horizontal ^layer <hlay> ^max <vcpo> ^min <vcom> ^com <hcom> ^max-net <nn> ^commo <hcmo> ^compo <hcpo>) + (make horizontal ^layer <vlay> ^min <hmin2> ^max <vcom> ^commo <hcmo> ^compo <hcpo> ^min-net <mn> ^max-net <nn> ^com <hcom>) + (modify 4 ^min <vcpo> ^min-net <nn>) + (make horizotnal ^net-name <nn> ^pin-name <pn> ^layer <vlay> ^min <vcom> ^max <vcpo> ^commo <hcmo> ^compo <hcpo> ^com <hcom>) + (remove 1) + (make move-via <nn> <hlay> <hcom> <vcom>) +) + +(p p372 + (move-via <nn>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmin1> ^max <vmax1> ^com <vcom1> ^layer <vlay> ^compo <vcpo1> ^commo <vcmo1> ^pin-name <pn1>) + (vertical ^status nil ^net-name { <nn> <> nil } ^min <vmax1> ^max <vmax2> ^com { <vcom2> > <vcom1> } ^layer <vlay> ^compo <vcpo2> ^commo <vcmo2> ^pin-name <pn2>) + { <h1> (horizontal ^status nil ^net-name { <nn> <> nil } ^min <vcom1> ^max <vcom2> ^com <vmax1> ^layer { <hlay> <> <vlay> }) } + { <h2> (horizontal ^status nil ^net-name nil ^min { <fmin> <= <vcom1> } ^max { <fmax> >= <vcom2> } ^com <vmax1> ^layer <vlay>) } + - (vertical ^min < <vmax1> ^max >= <vmax1> ^com { > <vcom1> < <vcom2> }) + --> + (remove <h2>) + (modify <h1> ^net-name nil ^pin-name nil ^min-net nil ^max-net nil) + (make (substr <h2> 1 inf) ^max <vcmo1> ^max-net nil) + (make (substr <h2> 1 inf) ^min <vcpo2> ^min-net nil) + (make (substr <h1> 1 inf) ^layer <vlay>) +) + +(p p373 + (move-via <nn> <lay> <x> <y>) + (horizontal ^min <x> ^max <garb1> ^com <y> ^layer <lay> ^min-net <nn> ^max-net <garb2>) + --> + (modify 2 ^min-net nil) +) + +(p p374 + (move-via <nn> <lay> <x> <y>) + (vertical ^min <y> ^max <garb1> ^com <x> ^layer <lay> ^min-net <nn> ^max-net <garb2>) + --> + (modify 2 ^min-net nil) +) + +(p p375 + (move-via <nn> <lay> <x> <y>) + (horizontal ^min <garb1> ^max <x> ^com <y> ^layer <lay> ^min-net <garb2> ^max-net <nn>) + --> + (modify 2 ^max-net nil) +) + +(p p376 + (move-via <nn> <lay> <x> <y>) + (vertical ^min <garb1> ^max <y> ^com <x> ^layer <lay> ^min-net <garb2> ^max-net <nn>) + --> + (modify 2 ^max-net nil) +) + +(p start-dummy + (start) + --> + (write (crlf) | Dummy START, do "loadwm" from "kuh.tmp".| (crlf)) +) + + -- GitLab