Merge branch 'master' of git.informatik.uni-kiel.de:sad/advanced-programming-ws19

Logic/advprog-swipl

+#!/bin/bash
+
+function fillIddfsFile {
+    (cat | base64 --decode > "$TMP_DIR/$IDDFS_FILE") << EOF
+Oi0gbW9kdWxlKCBmb3J0cHJvZwogICAgICAgICAsIFsgaWRkZnNfYXNzZXJ0SWZOb3RFeGlzdHMv
+MQogICAgICAgICAgICwgaWRkZnNfbWF4TGlzdC8yCiAgICAgICAgICAgLCBpZGRmc19pc05ld1Jl
+c3VsdC8yCiAgICAgICAgICAgLCBpZGRmc19zZWFyY2hEZXB0aC8xCiAgICAgICAgICAgLCBpZGRm
+c19zZXRfc3RlcC8xIF0KICAgICAgICAgKS4KOi0gZHluYW1pYyB1c2VyOmNvbnRpbnVlX2lkZGZz
+LzAuCjotIGR5bmFtaWMgdXNlcjppZGRmc19pc1VzZXJEZWZpbmVkLzIuCjotIGR5bmFtaWMgdXNl
+cjppZGRmc19zdGVwLzEuCjotIGR5bmFtaWMgdXNlcjpleHBhbmRfcXVlcnkvNC4KOi0gbXVsdGlm
+aWxlIHVzZXI6ZXhwYW5kX3F1ZXJ5LzQuCjotIG11bHRpZmlsZSB1c2VyOnRlcm1fZXhwYW5zaW9u
+LzIuCgoKJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSBBVFRFTlRJT04gJSUlJSUl
+JSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUKJSBUaGUgInJvb3QiIHByZWRpY2F0ZXMgYXJl
+IHRlcm1fZXhwYW5zaW9uLzIgYW5kIGV4cGFuZF9xdWVyeS80LCBhdCB0aGUgYm90dG9tCiUgb2Yg
+dGhpcyBmaWxlIChmb3IgdGVjaG5pY2FsIHJlYXNvbnMpLiBTa2lwIHRvIHRoZW0gdG8gdW5kZXJz
+dGFuZCB0aGUgb3RoZXIKJSBwcmVkaWNhdGVzLgolJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUl
+JSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJQoKCiUl
+JSUlIFNwZWNpYWwgcXVlcmllcyAlJSUlJQolIEhhbmRsZSB0aGUgc3BlY2lhbCBxdWVyeSBvZiBs
+b2FkaW5nIGEgbW9kdWxlIChkZXRlcm1pbmUgdXNlciBkZWZpbmVkCiUgcHJlZGljYXRlcyBiZWZv
+cmUpLgpleHBhbmRRdWVyeShbTW9kdWxlXSwgW01vZHVsZV0pCiAgICA6LSBhYnNvbHV0ZV9maWxl
+X25hbWUoTW9kdWxlLCBGaWxlTmFtZSwgW2V4dGVuc2lvbnMoWycucGwnXSldKQogICAgLCAgd3Jp
+dGUoRmlsZU5hbWUpLCBubAogICAgLCAgcHJlUHJvY2VzcyhGaWxlTmFtZSkuCgoKCiUlJSUlIFRo
+ZSBwdXJlIHRlcm0gZXhwYW5kaW5nIHByZWRpY2F0ZXMgJSUlJSUKJSBFeHBhbmQgYSBxdWVyeQol
+IGA/LSA8UXVlcnk+LmAKJQolIHRvCiUKJSBgPy0gaWRkZnNfYXNzZXJ0SWZOb3RFeGlzdHModXNl
+cjpjb250aW51ZV9pZGRmcykKJSAgICwgaWRkZnNfc2VhcmNoRGVwdGgoTWF4RGVwdGgpCiUgICAs
+IHJldHJhY3QodXNlcjpjb250aW51ZV9pZGRmcykKJSAgICwgPFF1ZXJ5X3VzaW5nX2V4cGFuZGVk
+X3ByZWRpY2F0ZXM+CiUgICAsIGlkZGZzX21heExpc3QoTHZscywgTHZsKQolICAgLCBpZGRmc19p
+c05ld1Jlc3VsdChMdmwsIE1heERlcHRoKS5gCmV4cGFuZFF1ZXJ5KFF1ZXJ5LCBOZXdRdWVyeSkK
+ICAgIDotIHRlcm1BbnkoaXNVc2VyRGVmaW5lZFRlcm0sIFF1ZXJ5KQogICAgLT4gKCBleHBhbmRC
+b2R5KE1heERlcHRoLCBRdWVyeSwgRXhwUXVlcnksIEx2bHMpCiAgICAgICAsIG1ha2VDb25qVGVy
+bShbIGlkZGZzX2Fzc2VydElmTm90RXhpc3RzKHVzZXI6Y29udGludWVfaWRkZnMpCiAgICAgICAg
+ICAgICAgICAgICAgICAsIGlkZGZzX3NlYXJjaERlcHRoKE1heERlcHRoKQogICAgICAgICAgICAg
+ICAgICAgICAgLCByZXRyYWN0KHVzZXI6Y29udGludWVfaWRkZnMpCiAgICAgICAgICAgICAgICAg
+ICAgICAsIEV4cFF1ZXJ5CiAgICAgICAgICAgICAgICAgICAgICAsIGlkZGZzX21heExpc3QoTHZs
+cywgTHZsKQogICAgICAgICAgICAgICAgICAgICAgLCBpZGRmc19pc05ld1Jlc3VsdChMdmwsIE1h
+eERlcHRoKSBdCiAgICAgICAgICAgICAgICAgICAgICwgTmV3UXVlcnkpCiAgICAgICAgKQogICAg
+OyBRdWVyeSA9IE5ld1F1ZXJ5LgoKZXhwYW5kUnVsZShIZWFkLCBCb2R5LCBOZXdIZWFkLCBOZXdC
+b2R5KQogICAgOi0gZnVuY3RvcihIZWFkLCBGdW5jdG9yLCBBcml0eSkKICAgICwgIHVzZXI6aWRk
+ZnNfaXNVc2VyRGVmaW5lZChGdW5jdG9yLCBBcml0eSkKICAgIC0+ICggZXhwYW5kUHJlZGljYXRp
+b24oTWF4RGVwdGgsIEhlYWQsIE5ld0hlYWQsIEx2bCkKICAgICAgICwgZXhwYW5kQm9keShNYXhE
+MSwgQm9keSwgVGVtcEJvZHkwLCBMdmxzKQogICAgICAgLCBleHBhbmRCb2R5QnlMdmxDYWxjKEx2
+bHMsIEx2bCwgVGVtcEJvZHkwLCBUZW1wQm9keTEpCiAgICAgICAsIGV4cGFuZEJvZHlCeURlcHRo
+Q2FsY0FuZEN1dChNYXhEZXB0aCwgTWF4RDEsIFRlbXBCb2R5MSwgTmV3Qm9keSkgKQogICAgOyAg
+KEhlYWQgPSBOZXdIZWFkLCBCb2R5ID0gTmV3Qm9keSkuCgolIEV4cGVjdCB0ZXJtIChhbmQgbm90
+IGl0cyBwYXJ0cyBnZW5lcmF0ZWQgYnkgYD0uLmApIGFzIGlucHV0LgpleHBhbmRQcmVkaWNhdGlv
+bihEZXB0aCwgQ29tcG91bmRUZXJtLCBFeHBhbnNpb24sIEx2bCkKICAgIDotIENvbXBvdW5kVGVy
+bSA9Li4gQ1RQYXJ0cwogICAgLCAgZXhwYW5kQ29tcG91bmRUZXJtUGFydHMoRGVwdGgsIENUUGFy
+dHMsIEV4cENUUGFydHMsIEx2bCkKICAgICwgIEV4cGFuc2lvbiA9Li4gRXhwQ1RQYXJ0cy4KCmV4
+cGFuZENvbXBvdW5kVGVybVBhcnRzKERlcHRoLCBbRnVuY3RvciB8IEFyZ3NdLCBbTmV3RnVuY3Rv
+ciB8IE5ld0FyZ3NdLCBMdmwpCiAgICA6LSBsZW5ndGgoQXJncywgTikKICAgICwgIHVzZXI6aWRk
+ZnNfaXNVc2VyRGVmaW5lZChGdW5jdG9yLCBOKQogICAgLT4gKCBhcHBlbmRBcmdzKFtEZXB0aCwg
+THZsXSwgQXJncywgTmV3QXJncykKICAgICAgICwgYXRvbV9jb25jYXQoRnVuY3RvciwgJ19pZGRm
+c19leHBhbmRlZCcsIE5ld0Z1bmN0b3IpCiAgICAgICApCiAgICAlIERvbid0IGV4cGFuZCBpZiBw
+cmVkaWNhdGUgaXMgbm90IHVzZXItZGVmaW5lZC4KICAgIDsgICggRnVuY3RvciA9IE5ld0Z1bmN0
+b3IKICAgICAgICwgQXJncyA9IE5ld0FyZ3MKICAgICAgICwgTHZsID0gMCApLgoKJSBFeHBlY3Qg
+dGVybSAoYW5kIG5vdCBpdHMgcGFydHMgZ2VuZXJhdGVkIGJ5IGA9Li5gKSBhcyBpbnB1dC4KJSBJ
+ZiBib2R5IGlzIGp1c3QgYSB2YXJpYWJsZSwgYD0uLmAgZG9lcyBub3Qgd29yay4KZXhwYW5kQm9k
+eShfICAgICwgVmFyQm9keSwgVmFyQm9keSwgWzBdKSA6LSB2YXIoVmFyQm9keSksICEuCmV4cGFu
+ZEJvZHkoRGVwdGgsIEJvZHkgICAsIE5ld0JvZHksIEx2bHMpCiAgICA6LSBCb2R5ID0uLiBCb2R5
+UGFydHMKICAgICwgIGV4cGFuZEJvZHlQYXJ0cyhEZXB0aCwgQm9keVBhcnRzLCBFeHBCb2R5UGFy
+dHMsIEx2bHMpCiAgICAsICBOZXdCb2R5ID0uLiBFeHBCb2R5UGFydHMuCgpleHBhbmRCb2R5UGFy
+dHMoRGVwdGgsIFssLCBMZWZ0LCBSaWdodF0sIFssLCBFeHBMZWZ0LCBFeHBSaWdodF0sIEx2bHMp
+CiAgICA6LSBleHBhbmRCb2R5KERlcHRoLCBMZWZ0LCBFeHBMZWZ0LCBMdmxzTGVmdCkKICAgICwg
+IGV4cGFuZEJvZHkoRGVwdGgsIFJpZ2h0LCBFeHBSaWdodCwgTHZsc1JpZ2h0KQogICAgLCAgYXBw
+ZW5kKEx2bHNMZWZ0LCBMdmxzUmlnaHQsIEx2bHMpLgpleHBhbmRCb2R5UGFydHMoRGVwdGgsIFs7
+LCBMZWZ0LCBSaWdodF0sIFs7LCBFeHBMZWZ0LCBFeHBSaWdodF0sIEx2bHMpCiAgICA6LSBleHBh
+bmRCb2R5KERlcHRoLCBMZWZ0LCBFeHBMZWZ0LCBMdmxzTGVmdCkKICAgICwgIGV4cGFuZEJvZHko
+RGVwdGgsIFJpZ2h0LCBFeHBSaWdodCwgTHZsc1JpZ2h0KQogICAgLCAgYXBwZW5kKEx2bHNMZWZ0
+LCBMdmxzUmlnaHQsIEx2bHMpLgpleHBhbmRCb2R5UGFydHMoRGVwdGgsIFstPiwgTGVmdCwgUmln
+aHRdLCBbLT4sIEV4cExlZnQsIEV4cFJpZ2h0XSwgTHZscykKICAgIDotIGV4cGFuZEJvZHkoRGVw
+dGgsIExlZnQsIEV4cExlZnQsIEx2bHNMZWZ0KQogICAgLCAgZXhwYW5kQm9keShEZXB0aCwgUmln
+aHQsIEV4cFJpZ2h0LCBMdmxzUmlnaHQpCiAgICAsICBhcHBlbmQoTHZsc0xlZnQsIEx2bHNSaWdo
+dCwgTHZscykuCmV4cGFuZEJvZHlQYXJ0cyhEZXB0aCwgW1wrLCBBcmddLCBbXCssIEV4cEFyZ10s
+IEx2bHMpCiAgICA6LSBleHBhbmRCb2R5KERlcHRoLCBBcmcsIEV4cEFyZywgTHZscykuCmV4cGFu
+ZEJvZHlQYXJ0cyhEZXB0aCwgUHJlZGljYXRpb25QYXJ0cywgTmV3UHJlZCwgW0x2bF0pCiAgICA6
+LSBQcmVkaWNhdGlvblRlcm0gPS4uIFByZWRpY2F0aW9uUGFydHMKICAgICwgIGV4cGFuZFByZWRp
+Y2F0aW9uKERlcHRoLCBQcmVkaWNhdGlvblRlcm0sIEV4cFByZWRUZXJtLCBMdmwpCiAgICAsICBF
+eHBQcmVkVGVybSA9Li4gTmV3UHJlZC4KCiUgVHJhbnNmb3JtCiUKJSA8Qm9keT4KJQolIHRvCiUK
+JSA8Qm9keT4sIGlkZGZzX21heExpc3QoTHZscywgTWF4THZsKSwgTHZsIGlzIE1heEx2bCArIDEK
+ZXhwYW5kQm9keUJ5THZsQ2FsYyhMdmxzLCBMdmwsIEJvZHksIE5ld0JvZHkpCiAgICA6LSBtYWtl
+Q29ualRlcm0oIFsgQm9keQogICAgICAgICAgICAgICAgICAgICAsIGlkZGZzX21heExpc3QoTHZs
+cywgTWF4THZsKQogICAgICAgICAgICAgICAgICAgICAsIEx2bCBpcyBNYXhMdmwgKyAxXQogICAg
+ICAgICAgICAgICAgICAgLCBOZXdCb2R5KS4KCiUgVHJhbnNmb3JtCiUgPEJvZHk+CiUKJSB0bwol
+CiUgTiA+IDAgLT4gKCBOMSBpcyBOIC0gMSwgPEJvZHk+ICkKJSAgICAgICAgOyAoaWRkZnNfYXNz
+ZXJ0SWZOb3RFeGlzdHModXNlcjpjb250aW51ZV9pZGRmcyksIGZhaWwpCmV4cGFuZEJvZHlCeURl
+cHRoQ2FsY0FuZEN1dChNYXhEZXB0aCwgTWF4RDEsIEJvZHksIE5ld0JvZHkpCiAgICA6LSBtYWtl
+Q29ualRlcm0oW01heEQxIGlzIE1heERlcHRoIC0gMSwgQm9keV0sIFRoZW5BY3Rpb24pCiAgICAs
+ICBtYWtlRGlzalRlcm0oWyBNYXhEZXB0aCA+IDAgLT4gVGhlbkFjdGlvbgogICAgICAgICAgICAg
+ICAgICAgICwgKGlkZGZzX2Fzc2VydElmTm90RXhpc3RzKHVzZXI6Y29udGludWVfaWRkZnMpCiAg
+ICAgICAgICAgICAgICAgICAgLCBmYWlsKV0KICAgICAgICAgICAgICAgICAgICwgTmV3Qm9keSku
+CgoKCiUlJSUlIFNwZWNpZmljIHV0aWxpdHkgcHJlZGljYXRlcyAlJSUlJQppZGRmc19hc3NlcnRJ
+Zk5vdEV4aXN0cyhUZXJtKSA6LSBcKyBUZXJtIC0+IGFzc2VydGEoVGVybSkgOyB0cnVlLgoKJSBU
+aGlzIGRldGVybWluZXMgdGhlIHN0ZXAgdXNlZCB0byBpbmNyZWFzZSB0aGUgc2VhcmNoIGRlcHRo
+LiBJdCBpcyBjb25maWd1cmFibGUKJSBieSB1c2luZyBgaWRkZnNfc2V0X3N0ZXAvMWAuCnVzZXI6
+aWRkZnNfc3RlcCgxKS4KCmlkZGZzX3NldF9zdGVwKE4pIDotIHJldHJhY3RhbGwodXNlcjppZGRm
+c19zdGVwKF8pKSwgYXNzZXJ0YSh1c2VyOmlkZGZzX3N0ZXAoTikpLgoKJSBDb3VudCBmcm9tIDAg
+dG8gaW5maW5pdHkgdXNpbmcgZ2xvYmFsIHN0ZXAgc2V0dGluZy4KaWRkZnNfc2VhcmNoRGVwdGgo
+MCkuCmlkZGZzX3NlYXJjaERlcHRoKEQpCiAgICA6LSB1c2VyOmNvbnRpbnVlX2lkZGZzCiAgICAs
+ICBpZGRmc19zZWFyY2hEZXB0aChEMSkKICAgICwgIHVzZXI6aWRkZnNfc3RlcChTdGVwKQogICAg
+LCAgRCBpcyBEMSArIFN0ZXAuCgppZGRmc19tYXhMaXN0KFtdLCAwKS4gJSBGb3Igb3VyIHB1cnBv
+c2UgdGhpcyBpcyBhIGdvb2QgY2hvaWNlLgppZGRmc19tYXhMaXN0KFsgWCB8IFhzIF0sIE1heCkK
+ICAgIDotIGlkZGZzX21heExpc3QoWHMsIE1heFNvRmFyKQogICAgLCAoZ3JvdW5kKFgpIC0+IE1h
+eCBpcyBtYXgoWCwgTWF4U29GYXIpCiAgICAgICAgICAgICAgICAgIDsgTWF4IGlzIE1heFNvRmFy
+KS4KCiUgQSByZXN1bHQgaXMgY29uc2lkZXJlZCBuZXcsIGlmIGl0IGlzIGZvdW5kIHdpdGhpbiBh
+IG5ldyBpbnRlcnZhbC4KaWRkZnNfaXNOZXdSZXN1bHQoTHZsLCBNYXhEZXB0aCkKICAgIDotIHVz
+ZXI6aWRkZnNfc3RlcChTdGVwKQogICAgLCAgTHZsID49IE1heERlcHRoIC0gU3RlcCArIDEuCgpw
+cmVQcm9jZXNzKE1vZHVsZSkKICAgIDotIG9wZW4oTW9kdWxlLCByZWFkLCBTdHJlYW0pCiAgICAs
+ICByZWFkX3Rlcm1zKFN0cmVhbSwgVGVybXMpCiAgICAsICBjaGVja0ZvcklsbGVnYWxPcHMoVGVy
+bXMpCiAgICAsICBnZXRVc2VyRGVmaW5lZFByZWRzKFRlcm1zKQogICAgLCAgY2xvc2UoU3RyZWFt
+KS4KCnJlYWRfdGVybXMoU3RyZWFtLCBbXSkKICAgIDotIGF0X2VuZF9vZl9zdHJlYW0oU3RyZWFt
+KS4KcmVhZF90ZXJtcyhTdHJlYW0sIFtUIHwgVHNdKQogICAgOi0gXCsgYXRfZW5kX29mX3N0cmVh
+bShTdHJlYW0pCiAgICAsICByZWFkKFN0cmVhbSwgVCkKICAgICwgIHJlYWRfdGVybXMoU3RyZWFt
+LCBUcykuCgpjaGVja0ZvcklsbGVnYWxPcHMoVGVybXMpIDotIGxpc3RBbnkodGVybUFueShpc0Zv
+cmJpZGRlbk9wKSwgVGVybXMpLCAhLgpjaGVja0ZvcklsbGVnYWxPcHMoXykuCgppc0ZvcmJpZGRl
+bk9wKFRlcm0pCiAgICA6LSBcKyB2YXIoVGVybSkKICAgIC0+IGZ1bmN0b3IoVGVybSwgJyEnLCAw
+KQogICAgLCAgc3ludGF4X2Vycm9yKCdJRERGUyBpcyBub3QgY29tcGF0aWJsZSB3aXRoIHRoZSBj
+dXQgKCEpIG9wZXJhdG9yIScpLgppc0ZvcmJpZGRlbk9wKFRlcm0pCiAgICA6LSBcKyB2YXIoVGVy
+bSkKICAgIC0+IGZ1bmN0b3IoVGVybSwgXCssIDEpCiAgICAsICBzeW50YXhfZXJyb3IoJ0lEREZT
+IGlzIG5vdCBjb21wYXRpYmxlIHdpdGggdGhlIG5lZ2F0aW9uIChcXCspIG9wZXJhdG9yIScpLgoK
+Z2V0VXNlckRlZmluZWRQcmVkcyhUZXJtcykKICAgIDotIHJldHJhY3RhbGwodXNlcjppZGRmc19p
+c1VzZXJEZWZpbmVkKF8sXykpCiAgICAsICBkaXNwYXRjaF90ZXJtcyhUZXJtcykuCgppc1VzZXJE
+ZWZpbmVkVGVybShUZXJtKQogICAgOi0gXCsgdmFyKFRlcm0pIC0+IGZ1bmN0b3IoVGVybSwgRiwg
+QSksIHVzZXI6aWRkZnNfaXNVc2VyRGVmaW5lZChGLCBBKS4KCm1hcmtBc1VzZXJEZWZpbmVkKFRl
+cm0pCiAgICA6LSBmdW5jdG9yKFRlcm0sIEYsIEEpCiAgICAsICBGIFw9IGVuZF9vZl9maWxlCiAg
+ICAtPiBpZGRmc19hc3NlcnRJZk5vdEV4aXN0cyh1c2VyOmlkZGZzX2lzVXNlckRlZmluZWQoRiwg
+QSkpCiAgICA7ICB0cnVlLgoKJSBUcmFuc2Zvcm0gdGVybXMgZnJvbSBhcmd1bWVudCBsaXN0IHRv
+IGFuIHJpZ2h0IGFzc29jaWF0aXZlIGNvbmp1bmN0aW9uIHRlcm0uCiUgRm9yIGV4YW1wbGU6IGBb
+dHJ1ZSwgZmFsc2UsIHRydWUsIGZhbHNlXWAgYmVjb21lcyBgdHJ1ZSwgKGZhbHNlLCAodHJ1ZSwg
+ZmFsc2UpKWAKbWFrZUNvbmpUZXJtKEFyZ3MsIFJlc3VsdCkgOi0gbWFrZU9wVGVybSgsLCBBcmdz
+LCBSZXN1bHQpLgoKJSBTZWUgYG1ha2VDb25qVGVybWAsIGJ1dCB3aXRoIGA7YCBpbnN0ZWFkIG9m
+IGAsYAptYWtlRGlzalRlcm0oQXJncywgUmVzdWx0KSA6LSBtYWtlT3BUZXJtKDssIEFyZ3MsIFJl
+c3VsdCkuCgphcHBlbmRBcmdzKEFyZ3MsIE9sZEFyZ3MsIE5ld0FyZ3MpIDotIGFwcGVuZChPbGRB
+cmdzLCBBcmdzLCBOZXdBcmdzKS4KCgoKJSUlJSUgR2VuZXJpYyB1dGlsaXR5IHByZWRpY2F0ZXMg
+JSUlJSUKJSBUcnVlIGlmIEdvYWwgY2FuIHN1Y2Nlc3NmdWxseSBiZSBhcHBsaWVkIG9uIHJvb3Qg
+dGVybSwgb3IgaWYgdGVybUFueShHb2FsLCBTVCkKJSBjYW4gY2FuIHN1Y2Nlc3NmdWxseSBiZSBh
+cHBsaWVkIG9uIGFueSBzdWJ0ZXJtIFNUIG9mIHRoZSByb290IHRlcm0uCiUgTWluZCB0aGF0IHRo
+ZSByb290IHRlcm0gY291bGQgYWxzbyBiZSBhIHZhcmlhYmxlIG9yIGFuIGF0b20uCnRlcm1Bbnko
+R29hbCwgVGVybSkgOi0gY2FsbChHb2FsLCBUZXJtKSwgIS4KdGVybUFueShHb2FsLCBUZXJtKQog
+ICAgOi0gXCsgdmFyKFRlcm0pCiAgICAtPiBUZXJtID0uLiBbIF8gfCBBcmdzIF0sIGxpc3RBbnko
+dGVybUFueShHb2FsKSwgQXJncykuCgolIFRydWUgaWYgR29hbCBjYW4gc3VjY2Vzc2Z1bGx5IGJl
+IGFwcGxpZWQgb24gYW55IGVsZW1lbnQgb2YgTGlzdApsaXN0QW55KEdvYWwsIFtYIHwgXyBdKSA6
+LSBjYWxsKEdvYWwsIFgpLCAhLgpsaXN0QW55KEdvYWwsIFtfIHwgWHNdKSA6LSBsaXN0QW55KEdv
+YWwsIFhzKS4KCiUgQ29udHJ1Y3QgdGVybSB1c2luZyBnaXZlbiBiaW5hcnkgb3AuIEZvciBleGFt
+cGxlOgolIG1ha2VPcFRlcm0oIG9wLCBbeDEsIC4uLiwgeG5dLCB4MSBvcCAoeDIgb3AgKC4uLigg
+eG4tMSBvcCB4bikuLi4pKSApLgptYWtlT3BUZXJtKF8gLCBbQXJnMF0sIFJlc3VsdCkgOi0gUmVz
+dWx0ID0gQXJnMC4KbWFrZU9wVGVybShPcCwgW0FyZzAsIEFyZzEgfCBBcmdzXSwgUmVzdWx0KQog
+ICAgOi0gbWFrZU9wVGVybShPcCwgW0FyZzEgfCBBcmdzXSwgVGVtcFJlcykKICAgICwgIFJlc3Vs
+dCA9Li4gW09wLCBBcmcwLCBUZW1wUmVzXS4KCgolJSUlJSBUaGUgRGlzcGF0Y2hpbmcgb2YgdGVy
+bXMgJSUlJSUKJSUlIERpc3BhdGNoaW5nIG5lZWRlZCBkdXJpbmcgdGVybSBleHBhbnNpb24KZGlz
+cGF0Y2goWzotLCBEaXJlY3RpdmVdLCBbOi0sIERpcmVjdGl2ZV0pIDotICEuCmRpc3BhdGNoKFs/
+LSwgUXVlcnldLCBbPy0sIE5ld1F1ZXJ5XSkgOi0gZXhwYW5kUXVlcnkoUXVlcnksIE5ld1F1ZXJ5
+KSwgIS4KZGlzcGF0Y2goWzotLCBIZWFkLCBCb2R5XSwgWzotLCBOZXdIZWFkLCBOZXdCb2R5XSkK
+ICAgIDotIGV4cGFuZFJ1bGUoSGVhZCwgQm9keSwgTmV3SGVhZCwgTmV3Qm9keSksICEuCmRpc3Bh
+dGNoKFByZWRpY2F0aW9uUGFydHMsIE5ld1ByZWQpCiAgICA6LSBQcmVkaWNhdGlvblRlcm0gPS4u
+IFByZWRpY2F0aW9uUGFydHMKICAgICwgIGV4cGFuZFByZWRpY2F0aW9uKF8sIFByZWRpY2F0aW9u
+VGVybSwgRXhwUHJlZFRlcm0sIDApCiAgICAsICBFeHBQcmVkVGVybSA9Li4gTmV3UHJlZC4KCiUl
+JSBEaXNwYXRjaGluZyBuZWVkZWQgZHVyaW5nIHF1ZXJ5IGV4cGFuc2lvbgpkaXNwYXRjaF90ZXJt
+cyhbXSkuCmRpc3BhdGNoX3Rlcm1zKFtUIHwgVHNdKSA6LSBUID0uLiBUUGFydHMsIGRpc3BhdGNo
+KFRQYXJ0cyksIGRpc3BhdGNoX3Rlcm1zKFRzKS4KCmRpc3BhdGNoKFs6LSwgX10pIDotICEuCmRp
+c3BhdGNoKFs/LSwgX10pIDotICEuCmRpc3BhdGNoKFs6LSwgSGVhZCwgX10pIDotIG1hcmtBc1Vz
+ZXJEZWZpbmVkKEhlYWQpLCAhLgpkaXNwYXRjaChQcmVkUGFydHMpIDotIFByZWQgPS4uIFByZWRQ
+YXJ0cywgIG1hcmtBc1VzZXJEZWZpbmVkKFByZWQpLgoKJSUlJSUgVGhlIGhvb2tzIHdoaWNoIGlu
+aXRpYXRlIHRlcm0gZXhwYW5zaW9uICUlJSUlCjotIGFzc2VydGEoKHVzZXI6ZXhwYW5kX3F1ZXJ5
+KFExLFEyLEIsQikgOi0gZXhwYW5kUXVlcnkoUTEsIFEyKSkpLgo6LSBhc3NlcnRhKCh1c2VyOnRl
+cm1fZXhwYW5zaW9uKFRlcm0sIEV4cGFuc2lvbikgOi0gVGVybSA9Li4gUGFydHMsIGRpc3BhdGNo
+KFBhcnRzLCBQcm9jZXNzZWRQYXJ0cyksIEV4cGFuc2lvbiA9Li4gUHJvY2Vzc2VkUGFydHMpKS4K
+CiUlJSBHcmVldGluZyBtZXNzYWdlOgo6LSB3cml0ZSgnV2VsY29tZSB0byBTV0ktUHJvbG9nIChl
+eHRlbmRlZCBXSVRIIENPTVBMRVRFIFNFQVJDSCBmb3IgRm9ydFByb2csIDIwLzAxLzE3KS4nKSwK
+ICAgbmwuCg==
+EOF
+}
+
+TMP_DIR="$(mktemp -d)"
+IDDFS_FILE="iddfs.pl"
+touch "$TMP_DIR/$IDDFS_FILE"
+
+fillIddfsFile
+
+swipl --quiet -s "$TMP_DIR/$IDDFS_FILE"
+
+rm -R "$TMP_DIR"
\ No newline at end of file

Logic/advprog.pl

+:- module( fortprog
+         , [ iddfs_assertIfNotExists/1
+           , iddfs_maxList/2
+           , iddfs_isNewResult/2
+           , iddfs_searchDepth/1
+           , iddfs_set_step/1 ]
+         ).
+:- dynamic user:continue_iddfs/0.
+:- dynamic user:iddfs_isUserDefined/2.
+:- dynamic user:iddfs_step/1.
+:- dynamic user:expand_query/4.
+:- multifile user:expand_query/4.
+:- multifile user:term_expansion/2.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ATTENTION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% The "root" predicates are term_expansion/2 and expand_query/4, at the bottom
+% of this file (for technical reasons). Skip to them to understand the other
+% predicates.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+%%%%% Special queries %%%%%
+% Handle the special query of loading a module (determine user defined
+% predicates before).
+expandQuery([Module], [Module])
+    :- absolute_file_name(Module, FileName, [extensions(['.pl'])])
+    ,  write(FileName), nl
+    ,  preProcess(FileName).
+
+
+
+%%%%% The pure term expanding predicates %%%%%
+% Expand a query
+% `?- <Query>.`
+%
+% to
+%
+% `?- iddfs_assertIfNotExists(user:continue_iddfs)
+%   , iddfs_searchDepth(MaxDepth)
+%   , retract(user:continue_iddfs)
+%   , <Query_using_expanded_predicates>
+%   , iddfs_maxList(Lvls, Lvl)
+%   , iddfs_isNewResult(Lvl, MaxDepth).`
+expandQuery(Query, NewQuery)
+    :- termAny(isUserDefinedTerm, Query)
+    -> ( expandBody(MaxDepth, Query, ExpQuery, Lvls)
+       , makeConjTerm([ iddfs_assertIfNotExists(user:continue_iddfs)
+                      , iddfs_searchDepth(MaxDepth)
+                      , retract(user:continue_iddfs)
+                      , ExpQuery
+                      , iddfs_maxList(Lvls, Lvl)
+                      , iddfs_isNewResult(Lvl, MaxDepth) ]
+                     , NewQuery)
+        )
+    ; Query = NewQuery.
+
+expandRule(Head, Body, NewHead, NewBody)
+    :- functor(Head, Functor, Arity)
+    ,  user:iddfs_isUserDefined(Functor, Arity)
+    -> ( expandPredication(MaxDepth, Head, NewHead, Lvl)
+       , expandBody(MaxD1, Body, TempBody0, Lvls)
+       , expandBodyByLvlCalc(Lvls, Lvl, TempBody0, TempBody1)
+       , expandBodyByDepthCalcAndCut(MaxDepth, MaxD1, TempBody1, NewBody) )
+    ;  (Head = NewHead, Body = NewBody).
+
+% Expect term (and not its parts generated by `=..`) as input.
+expandPredication(Depth, CompoundTerm, Expansion, Lvl)
+    :- CompoundTerm =.. CTParts
+    ,  expandCompoundTermParts(Depth, CTParts, ExpCTParts, Lvl)
+    ,  Expansion =.. ExpCTParts.
+
+expandCompoundTermParts(Depth, [Functor | Args], [NewFunctor | NewArgs], Lvl)
+    :- length(Args, N)
+    ,  user:iddfs_isUserDefined(Functor, N)
+    -> ( appendArgs([Depth, Lvl], Args, NewArgs)
+       , atom_concat(Functor, '_iddfs_expanded', NewFunctor)
+       )
+    % Don't expand if predicate is not user-defined.
+    ;  ( Functor = NewFunctor
+       , Args = NewArgs
+       , Lvl = 0 ).
+
+% Expect term (and not its parts generated by `=..`) as input.
+% If body is just a variable, `=..` does not work.
+expandBody(_    , VarBody, VarBody, [0]) :- var(VarBody), !.
+expandBody(Depth, Body   , NewBody, Lvls)
+    :- Body =.. BodyParts
+    ,  expandBodyParts(Depth, BodyParts, ExpBodyParts, Lvls)
+    ,  NewBody =.. ExpBodyParts.
+
+expandBodyParts(Depth, [,, Left, Right], [,, ExpLeft, ExpRight], Lvls)
+    :- expandBody(Depth, Left, ExpLeft, LvlsLeft)
+    ,  expandBody(Depth, Right, ExpRight, LvlsRight)
+    ,  append(LvlsLeft, LvlsRight, Lvls).
+expandBodyParts(Depth, [;, Left, Right], [;, ExpLeft, ExpRight], Lvls)
+    :- expandBody(Depth, Left, ExpLeft, LvlsLeft)
+    ,  expandBody(Depth, Right, ExpRight, LvlsRight)
+    ,  append(LvlsLeft, LvlsRight, Lvls).
+expandBodyParts(Depth, [->, Left, Right], [->, ExpLeft, ExpRight], Lvls)
+    :- expandBody(Depth, Left, ExpLeft, LvlsLeft)
+    ,  expandBody(Depth, Right, ExpRight, LvlsRight)
+    ,  append(LvlsLeft, LvlsRight, Lvls).
+expandBodyParts(Depth, [\+, Arg], [\+, ExpArg], Lvls)
+    :- expandBody(Depth, Arg, ExpArg, Lvls).
+expandBodyParts(Depth, PredicationParts, NewPred, [Lvl])
+    :- PredicationTerm =.. PredicationParts
+    ,  expandPredication(Depth, PredicationTerm, ExpPredTerm, Lvl)
+    ,  ExpPredTerm =.. NewPred.
+
+% Transform
+%
+% <Body>
+%
+% to
+%
+% <Body>, iddfs_maxList(Lvls, MaxLvl), Lvl is MaxLvl + 1
+expandBodyByLvlCalc(Lvls, Lvl, Body, NewBody)
+    :- makeConjTerm( [ Body
+                     , iddfs_maxList(Lvls, MaxLvl)
+                     , Lvl is MaxLvl + 1]
+                   , NewBody).
+
+% Transform
+% <Body>
+%
+% to
+%
+% N > 0 -> ( N1 is N - 1, <Body> )
+%        ; (iddfs_assertIfNotExists(user:continue_iddfs), fail)
+expandBodyByDepthCalcAndCut(MaxDepth, MaxD1, Body, NewBody)
+    :- makeConjTerm([MaxD1 is MaxDepth - 1, Body], ThenAction)
+    ,  makeDisjTerm([ MaxDepth > 0 -> ThenAction
+                    , (iddfs_assertIfNotExists(user:continue_iddfs)
+                    , fail)]
+                   , NewBody).
+
+
+
+%%%%% Specific utility predicates %%%%%
+iddfs_assertIfNotExists(Term) :- \+ Term -> asserta(Term) ; true.
+
+% This determines the step used to increase the search depth. It is configurable
+% by using `iddfs_set_step/1`.
+user:iddfs_step(1).
+
+iddfs_set_step(N) :- retractall(user:iddfs_step(_)), asserta(user:iddfs_step(N)).
+
+% Count from 0 to infinity using global step setting.
+iddfs_searchDepth(0).
+iddfs_searchDepth(D)
+    :- user:continue_iddfs
+    ,  iddfs_searchDepth(D1)
+    ,  user:iddfs_step(Step)
+    ,  D is D1 + Step.
+
+iddfs_maxList([], 0). % For our purpose this is a good choice.
+iddfs_maxList([ X | Xs ], Max)
+    :- iddfs_maxList(Xs, MaxSoFar)
+    , (ground(X) -> Max is max(X, MaxSoFar)
+                  ; Max is MaxSoFar).
+
+% A result is considered new, if it is found within a new interval.
+iddfs_isNewResult(Lvl, MaxDepth)
+    :- user:iddfs_step(Step)
+    ,  Lvl >= MaxDepth - Step + 1.
+
+preProcess(Module)
+    :- open(Module, read, Stream)
+    ,  read_terms(Stream, Terms)
+    ,  checkForIllegalOps(Terms)
+    ,  getUserDefinedPreds(Terms)
+    ,  close(Stream).
+
+read_terms(Stream, [])
+    :- at_end_of_stream(Stream).
+read_terms(Stream, [T | Ts])
+    :- \+ at_end_of_stream(Stream)
+    ,  read(Stream, T)
+    ,  read_terms(Stream, Ts).
+
+checkForIllegalOps(Terms) :- listAny(termAny(isForbiddenOp), Terms), !.
+checkForIllegalOps(_).
+
+isForbiddenOp(Term)
+    :- \+ var(Term)
+    -> functor(Term, '!', 0)
+    ,  syntax_error('IDDFS is not compatible with the cut (!) operator!').
+isForbiddenOp(Term)
+    :- \+ var(Term)
+    -> functor(Term, \+, 1)
+    ,  syntax_error('IDDFS is not compatible with the negation (\\+) operator!').
+
+getUserDefinedPreds(Terms)
+    :- retractall(user:iddfs_isUserDefined(_,_))
+    ,  dispatch_terms(Terms).
+
+isUserDefinedTerm(Term)
+    :- \+ var(Term) -> functor(Term, F, A), user:iddfs_isUserDefined(F, A).
+
+markAsUserDefined(Term)
+    :- functor(Term, F, A)
+    ,  F \= end_of_file
+    -> iddfs_assertIfNotExists(user:iddfs_isUserDefined(F, A))
+    ;  true.
+
+% Transform terms from argument list to an right associative conjunction term.
+% For example: `[true, false, true, false]` becomes `true, (false, (true, false))`
+makeConjTerm(Args, Result) :- makeOpTerm(,, Args, Result).
+
+% See `makeConjTerm`, but with `;` instead of `,`
+makeDisjTerm(Args, Result) :- makeOpTerm(;, Args, Result).
+
+appendArgs(Args, OldArgs, NewArgs) :- append(OldArgs, Args, NewArgs).
+
+
+
+%%%%% Generic utility predicates %%%%%
+% True if Goal can successfully be applied on root term, or if termAny(Goal, ST)
+% can can successfully be applied on any subterm ST of the root term.
+% Mind that the root term could also be a variable or an atom.
+termAny(Goal, Term) :- call(Goal, Term), !.
+termAny(Goal, Term)
+    :- \+ var(Term)
+    -> Term =.. [ _ | Args ], listAny(termAny(Goal), Args).
+
+% True if Goal can successfully be applied on any element of List
+listAny(Goal, [X | _ ]) :- call(Goal, X), !.
+listAny(Goal, [_ | Xs]) :- listAny(Goal, Xs).
+
+% Contruct term using given binary op. For example:
+% makeOpTerm( op, [x1, ..., xn], x1 op (x2 op (...( xn-1 op xn)...)) ).
+makeOpTerm(_ , [Arg0], Result) :- Result = Arg0.
+makeOpTerm(Op, [Arg0, Arg1 | Args], Result)
+    :- makeOpTerm(Op, [Arg1 | Args], TempRes)
+    ,  Result =.. [Op, Arg0, TempRes].
+
+
+%%%%% The Dispatching of terms %%%%%
+%%% Dispatching needed during term expansion
+dispatch([:-, Directive], [:-, Directive]) :- !.
+dispatch([?-, Query], [?-, NewQuery]) :- expandQuery(Query, NewQuery), !.
+dispatch([:-, Head, Body], [:-, NewHead, NewBody])
+    :- expandRule(Head, Body, NewHead, NewBody), !.
+dispatch(PredicationParts, NewPred)
+    :- PredicationTerm =.. PredicationParts
+    ,  expandPredication(_, PredicationTerm, ExpPredTerm, 0)
+    ,  ExpPredTerm =.. NewPred.
+
+%%% Dispatching needed during query expansion
+dispatch_terms([]).
+dispatch_terms([T | Ts]) :- T =.. TParts, dispatch(TParts), dispatch_terms(Ts).
+
+dispatch([:-, _]) :- !.
+dispatch([?-, _]) :- !.
+dispatch([:-, Head, _]) :- markAsUserDefined(Head), !.
+dispatch(PredParts) :- Pred =.. PredParts,  markAsUserDefined(Pred).
+
+%%%%% The hooks which initiate term expansion %%%%%
+:- asserta((user:expand_query(Q1,Q2,B,B) :- expandQuery(Q1, Q2))).
+:- asserta((user:term_expansion(Term, Expansion) :- Term =.. Parts, dispatch(Parts, ProcessedParts), Expansion =.. ProcessedParts)).
+
+%%% Greeting message:
+:- write('Welcome to SWI-Prolog (extended WITH COMPLETE SEARCH for FortProg, 20/01/17).'),
+   nl.
\ No newline at end of file

Logic/exercise/exercise1.md

+## 1. Exercise
+
+### Solutions will be checked on Wednesday, January, 19, 4pm to 6pm (Mini-test).
+
+1. *Who is on board?*
+
+   A Quidditch club would like to put together a three-person board consisting of a chairperson, a treasurer and a secretary. The candidates are *Potter*, *Weasley*, *Malfoy* and *Granger*. There are however different preferences of the individual members, which limit the possibilities for the formation of a board.
+
+   1. *Potter* and *Malfoy* do not want to join the board together.
+   2. *Malfoy* is only available for the board if *Granger* becomes chairperson.
+   3. *Weasley* will only join the board if *Potter* also belongs to it.
+   4. *Potter* does not want to join the board if *Granger* becomes the secretary.
+   5. *Granger* does not join the board if *Weasley* becomes chairperson.
+
+   Write a Prolog program that calculates all possible board member constellations.
+
+   **Note:** Make sure to avoid duplicate answers!
+
+1. *Predicates*
+   1. Add the following predicates to the [family example](asset-89071) from the lecture.
+
+      * `son(S, P)` is fulfilled if `S` is a son of `P`.
+      * `cousin(C, P)` is fulfilled if `C` is a cousin (male or female) of `P`.
+      * `brother_in_law(B, P)` is fulfilled if `B` is a brother in law of `P`.
+      * `ancestor(A, P)` is fulfilled if `A` is an ancestor of `P`.
+
+   2. Implement the following predicates using the [`append` predicate](asset-89070) from the lecture.
+
+      * `lookup(K, KVs, V)` is fulfilled if the tuple `(K, V)` is included in the list `KVs`.
+      * `member2(E, L)` is fulfilled if `E` is included at least twice in the list `L`.
+      * `reverse(Xs, Ys)` is fulfilled if the inversion of list `Xs` corresponds to list `Ys`. Implement both the naive and the efficient variant (accumulator technique using an additional argument).
+      * `sublist(Xs, Ys)` is fulfilled if `Xs` occurs as a sublist in `Ys`.
+
+1. *Binary Numbers*
+   In the lecture we presented natural numbers as Peano numbers. However, this representation is very inefficient for large numbers. We therefore want to present natural numbers as binary numbers.
+
+   * We distinguish the number 0, represented as `o`, and positive numbers >0 represented as `pos(N)`.
+   * Positive numbers are represented as a bit sequence, where the most significant bit is always 1, so there are no leading zeros. Positive numbers consist of the following functors.
+
+     * A term of the form `o(N)` represents the number 2*N,
+     * a term of the form `i(N)` represents the number 2*N+1 and
+     * the atom `i` represents the number 1 (most significant bit).
+
+   The number 0 is therefore called `o`, 1 as `pos(i)` and 4 as `pos(o(o(i))`. Hence, the outermost functor represents the least significant bit.
+
+   1. Define the following predicates based on this number representation.
+
+      * Addition of two natural numbers `add(X, Y, Res)`.
+      * Subtraction of two natural numbers `sub(X, Y, Res)`.
+
+      **Note:** Use auxiliary predicates such as `addP`, which are defined on positive numbers. Furthermore, use the following equations and develop equations for further combinations if necessary.
+
+      ~~~
+        1+1           = 2
+        1+(2 * N)     = 2 * N+1
+        1+(2 * N + 1) = 2 * (N+1)
+      ~~~
+
+   2. When used in the opposite direction, e.g. with a query like `add(X, Y, pos(o(i)))`, Prolog computes all solutions, but, unfortunately, does not terminate. The reason is, that the Prolog program does not know that the sum of two positive numbers is greater than each summand, and thus increasing summands are tried.
+
+      Implement for positive numbers >0 a predicate `lessP(X, Y)` that is satisfied, when `X` is less than `Y`. Then use this predicate to improve the previous implementation of `add`.
+
+1. *Boolean Operations*
+   Implement Boolean functions `and`, `or`, and `not` as predicates working on the values `true` and `false`. Make sure that negation is also possible. Therefore, you must provide an explicit result as an additional parameter of your predicate.
+
+   Also implement the following three Boolean expressions as Prolog predicates `ex1(X, Y, Z, Res)`, `ex2(X, Y, Z, Res)`, and `ex3(X, Y, Z, Res)`.
+
+   * (X /\ Y) \/ Z
+   * (X /\ Y) \/ ((Y /\ Z) /\ Z)
+   * (X /\ (not Y) /\ Z) \/ ((Z /\ Y) \/ Z)
+
+   Specify queries that can be used to answer the following questions. Give the answer of the Prolog system as well as an additional explanation.
+
+   * Which results do you get for the values `X = true`, `Y = false` and `Z = true`?
+   * Which assignments yield `true` as result?
+   * Is the third equation dependent on `X` or `Z`?

Logic/lecture/family.pl

+mother(susanne,monika).
+mother(norbert,monika).
+mother(monika,ulrike).
+mother(herbert,christine).
+mother(andreas,angelika).
+mother(angelika,christine).
+mother(hubert,maria).
+
+female(susanne).
+female(P) :- mother(_,P).
+
+husband(monika,herbert).
+husband(angelika,hubert).
+husband(christine,heinz).
+husband(maria,fritz).
+
+father(C,F) :- mother(C,M), husband(M,F).
+
+grandmother(C,GM) :- mother(C,M), mother(M,GM).
+grandmother(C,GM) :- father(C,F), mother(F,GM).
+
+sibling(P1,P2) :- mother(P1,M), mother(P2,M), P1\=P2.
+
+sister(P,S) :- sibling(P,S), female(S). 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

Logic/lecture/lists.pl

+
+date(date(_,_,_)).
+
+year(date(_,_,Y),Y).
+month(date(_,M,_),M).
+day(date(D,_,_),D).
+
+% data Tree where
+%   Leaf :: Int -> Tree
+%   Branch :: Tree -> Tree -> Tree
+
+tree(leaf(_)).
+tree(branch(TL,TR)) :- tree(TL),tree(TR).
+
+list([]).
+list([_|Xs]) :- list(Xs).
+
+memb(E,[E|_]).
+memb(E,[_|Xs]) :- memb(E,Xs).
+
+% (++) :: [a] -> [a] -> [a]
+% []     ++ ys = ys
+% (x:xs) ++ ys = x : (xs ++ ys)
+% app([a],[a],[a])
+% the result of a function gets an additional argument
+% (usually in the end).
+
+app([]    ,Ys,Ys).
+app([X|Xs],Ys,[X|Zs]) :- app(Xs,Ys,Zs).
+
+prefix(Xs,Ys) :- app(Xs,_,Ys).
+
+suffix(Xs,Ys) :- app(_,Xs,Ys).
+
+sublist(Xs,Ys) :-  prefix(Zs,Ys), suffix(Xs,Zs).
+
+mem(E,Xs) :- sublist([E],Xs).
+
+isPeano(o).
+isPeano(s(N)) :- isPeano(N).
+
+add(o   ,M,M).
+add(s(N),M,s(R)) :- add(N,M,R).
+
+sub(N,M,R) :- add(M,R,N).
+
+leq(o,_).
+leq(s(N),s(M)) :- leq(N,M).
+
+len([],o).
+len([_|Xs],s(R)) :- len(Xs,R).
+
+% programmin pattern: generate and test