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