Post order traversal of n-ary tree
Here given code implementation process.
import java.util.Vector;
import java.util.ArrayList;
// Java program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
public int key;
public Vector < TreeNode > child;
public TreeNode(int key)
{
// Set node key
this.key = key;
// Create memory of TreeNode child
this.child = new Vector < TreeNode > ();
}
public void addChild(int key)
{
// Create a new node
TreeNode node = new TreeNode(key);
// Add node into child
this.child.add(node);
}
}
public class NAryTree
{
public TreeNode root;
public NAryTree()
{
// Set initial tree root to null
this.root = null;
}
public void printPostOrder(TreeNode node)
{
if(node == null)
{
return;
}
for (int i = 0; i < node.child.size() ; ++i)
{
// Visit child node
printPostOrder(node.child.get(i));
}
// Display node value
System.out.print(" "+node.key);
}
public static void main(String[] args)
{
NAryTree tree = new NAryTree();
/*
10
/ \
/ \
/ \
8 5
/|\ /|\ \
/ | \ / | \ \
-2 1 6 7 18 3 4
/ \ /| \
9 11 2 1 3
/ \
17 12
-----------------------
Constructing N-Arr tree
*/
// First element of tree
tree.root = new TreeNode(10);
tree.root.addChild(8);
tree.root.addChild(5);
// Add child node [-2,1,6] in node (8)
tree.root.child.get(0).addChild(-2);
tree.root.child.get(0).addChild(1);
tree.root.child.get(0).addChild(6);
// Add child node [9,11] in node (1)
tree.root.child.get(0).child.get(1).addChild(9);
tree.root.child.get(0).child.get(1).addChild(11);
// Add child node [17 12] in node (11)
tree.root.child.get(0).child.get(1).child.get(1).addChild(17);
tree.root.child.get(0).child.get(1).child.get(1).addChild(12);
// Add child node [7 18 3 4] in node (5)
tree.root.child.get(1).addChild(7);
tree.root.child.get(1).addChild(18);
tree.root.child.get(1).addChild(3);
tree.root.child.get(1).addChild(4);
// Add child node [2,1,3] in node (4)
tree.root.child.get(1).child.get(3).addChild(2);
tree.root.child.get(1).child.get(3).addChild(1);
tree.root.child.get(1).child.get(3).addChild(3);
tree.printPostOrder(tree.root);
}
}
Output
-2 9 17 12 11 1 6 8 7 18 3 2 1 3 4 5 10
package main
import "fmt"
// Go program for
// Postorder traversal of an N-ary Tree
type TreeNode struct {
key int
child [] *TreeNode
}
func getTreeNode(key int) * TreeNode {
var me *TreeNode = &TreeNode {}
// Set node key
me.key = key
// Create memory of TreeNode child
me.child = make([] *TreeNode,0)
return me
}
func(this *TreeNode) addChild(key int) {
// Create a new node
var node * TreeNode = getTreeNode(key)
// Add node into child
this.child = append(this.child, node)
}
type NAryTree struct {
root * TreeNode
}
func getNAryTree() * NAryTree {
var me *NAryTree = &NAryTree {}
// Set initial tree root to null
me.root = nil
return me
}
func(this NAryTree) printPostOrder(node * TreeNode) {
if node == nil {
return
}
for i := 0 ; i < len(node.child) ; i++ {
// Visit child node
this.printPostOrder(node.child[i])
}
// Display node value
fmt.Print(" ", node.key)
}
func main() {
var tree * NAryTree = getNAryTree()
/*
10
/ \
/ \
/ \
8 5
/|\ /|\ \
/ | \ / | \ \
-2 1 6 7 18 3 4
/ \ /| \
9 11 2 1 3
/ \
17 12
-----------------------
Constructing N-Ary tree
*/
// First element of tree
tree.root = getTreeNode(10)
tree.root.addChild(8)
tree.root.addChild(5)
// Add child node [-2,1,6] in node (8)
tree.root.child[0].addChild(-2)
tree.root.child[0].addChild(1)
tree.root.child[0].addChild(6)
// Add child node [9,11] in node (1)
tree.root.child[0].child[1].addChild(9)
tree.root.child[0].child[1].addChild(11)
// Add child node [17 12] in node (11)
tree.root.child[0].child[1].child[1].addChild(17)
tree.root.child[0].child[1].child[1].addChild(12)
// Add child node [7 18 3 4] in node (5)
tree.root.child[1].addChild(7)
tree.root.child[1].addChild(18)
tree.root.child[1].addChild(3)
tree.root.child[1].addChild(4)
// Add child node [2,1,3] in node (4)
tree.root.child[1].child[3].addChild(2)
tree.root.child[1].child[3].addChild(1)
tree.root.child[1].child[3].addChild(3)
tree.printPostOrder(tree.root)
}
Output
-2 9 17 12 11 1 6 8 7 18 3 2 1 3 4 5 10
// Include header file
#include <iostream>
#include <vector>
using namespace std;
// C++ program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
public: int key;
vector < TreeNode *> child;
TreeNode(int key)
{
// Set node key
this->key = key;
}
void addChild(int key)
{
// Create a new node
TreeNode *node = new TreeNode(key);
// Add node into child
this->child.push_back(node);
}
};
class NAryTree
{
public: TreeNode *root;
NAryTree()
{
this->root = NULL;
}
void printPostOrder(TreeNode *node)
{
if (node == NULL)
{
return;
}
for (int i = 0; i < node->child.size(); ++i)
{
// Visit child node
this->printPostOrder(node->child.at(i));
}
// Display node value
cout << " " << node->key;
}
};
int main()
{
NAryTree *tree = new NAryTree();
/*
10
/ \
/ \
/ \
8 5
/|\ /|\ \
/ | \ / | \ \
-2 1 6 7 18 3 4
/ \ /| \
9 11 2 1 3
/ \
17 12
-----------------------
Constructing N-Arr tree
*/
// First element of tree
tree->root = new TreeNode(10);
tree->root->addChild(8);
tree->root->addChild(5);
// Add child node [-2,1,6] in node (8)
tree->root->child.at(0)->addChild(-2);
tree->root->child.at(0)->addChild(1);
tree->root->child.at(0)->addChild(6);
// Add child node [9,11] in node (1)
tree->root->child.at(0)->child.at(1)->addChild(9);
tree->root->child.at(0)->child.at(1)->addChild(11);
// Add child node [17 12] in node (11)
tree->root->child.at(0)->child.at(1)->child.at(1)->addChild(17);
tree->root->child.at(0)->child.at(1)->child.at(1)->addChild(12);
// Add child node [7 18 3 4] in node (5)
tree->root->child.at(1)->addChild(7);
tree->root->child.at(1)->addChild(18);
tree->root->child.at(1)->addChild(3);
tree->root->child.at(1)->addChild(4);
// Add child node [2,1,3] in node (4)
tree->root->child.at(1)->child.at(3)->addChild(2);
tree->root->child.at(1)->child.at(3)->addChild(1);
tree->root->child.at(1)->child.at(3)->addChild(3);
tree->printPostOrder(tree->root);
return 0;
}
Output
-2 9 17 12 11 1 6 8 7 18 3 2 1 3 4 5 10
// Include namespace system
using System;
using System.Collections.Generic;
// Csharp program for
// Postorder traversal of an N-ary Tree
public class TreeNode
{
public int key;
public List < TreeNode > child;
public TreeNode(int key)
{
// Set node key
this.key = key;
// Create memory of TreeNode child
this.child = new List < TreeNode > ();
}
public void addChild(int key)
{
// Create a new node
TreeNode node = new TreeNode(key);
// Add node into child
this.child.Add(node);
}
}
public class NAryTree
{
public TreeNode root;
public NAryTree()
{
// Set initial tree root to null
this.root = null;
}
public void printPostOrder(TreeNode node)
{
if (node == null)
{
return;
}
for (int i = 0; i < node.child.Count; ++i)
{
// Visit child node
this.printPostOrder(node.child[i]);
}
// Display node value
Console.Write(" " + node.key);
}
public static void Main(String[] args)
{
NAryTree tree = new NAryTree();
/*
10
/ \
/ \
/ \
8 5
/|\ /|\ \
/ | \ / | \ \
-2 1 6 7 18 3 4
/ \ /| \
9 11 2 1 3
/ \
17 12
-----------------------
Constructing N-Arr tree
*/
// First element of tree
tree.root = new TreeNode(10);
tree.root.addChild(8);
tree.root.addChild(5);
// Add child node [-2,1,6] in node (8)
tree.root.child[0].addChild(-2);
tree.root.child[0].addChild(1);
tree.root.child[0].addChild(6);
// Add child node [9,11] in node (1)
tree.root.child[0].child[1].addChild(9);
tree.root.child[0].child[1].addChild(11);
// Add child node [17 12] in node (11)
tree.root.child[0].child[1].child[1].addChild(17);
tree.root.child[0].child[1].child[1].addChild(12);
// Add child node [7 18 3 4] in node (5)
tree.root.child[1].addChild(7);
tree.root.child[1].addChild(18);
tree.root.child[1].addChild(3);
tree.root.child[1].addChild(4);
// Add child node [2,1,3] in node (4)
tree.root.child[1].child[3].addChild(2);
tree.root.child[1].child[3].addChild(1);
tree.root.child[1].child[3].addChild(3);
tree.printPostOrder(tree.root);
}
}
Output
-2 9 17 12 11 1 6 8 7 18 3 2 1 3 4 5 10
<?php
// Php program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
public $key;
public $child;
public function __construct($key)
{
// Set node key
$this->key = $key;
// Create memory of TreeNode child
$this->child = array();
}
public function addChild($key)
{
// Create a new node
$node = new TreeNode($key);
// Add node into child
$this->child[] = $node;
}
}
class NAryTree
{
public $root;
public function __construct()
{
$this->root = NULL;
}
public function printPostOrder($node)
{
if ($node == NULL)
{
return;
}
for ($i = 0; $i < count($node->child); ++$i)
{
// Visit child node
$this->printPostOrder($node->child[$i]);
}
// Display node value
echo(" ".$node->key);
}
}
function main()
{
$tree = new NAryTree();
/*
10
/ \
/ \
/ \
8 5
/|\ /|\ \
/ | \ / | \ \
-2 1 6 7 18 3 4
/ \ /| \
9 11 2 1 3
/ \
17 12
-----------------------
Constructing N-Arr tree
*/
// First element of tree
$tree->root = new TreeNode(10);
$tree->root->addChild(8);
$tree->root->addChild(5);
// Add child node [-2,1,6] in node (8)
$tree->root->child[0]->addChild(-2);
$tree->root->child[0]->addChild(1);
$tree->root->child[0]->addChild(6);
// Add child node [9,11] in node (1)
$tree->root->child[0]->child[1]->addChild(9);
$tree->root->child[0]->child[1]->addChild(11);
// Add child node [17 12] in node (11)
$tree->root->child[0]->child[1]->child[1]->addChild(17);
$tree->root->child[0]->child[1]->child[1]->addChild(12);
// Add child node [7 18 3 4] in node (5)
$tree->root->child[1]->addChild(7);
$tree->root->child[1]->addChild(18);
$tree->root->child[1]->addChild(3);
$tree->root->child[1]->addChild(4);
// Add child node [2,1,3] in node (4)
$tree->root->child[1]->child[3]->addChild(2);
$tree->root->child[1]->child[3]->addChild(1);
$tree->root->child[1]->child[3]->addChild(3);
$tree->printPostOrder($tree->root);
}
main();
Output
-2 9 17 12 11 1 6 8 7 18 3 2 1 3 4 5 10
// Node JS program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
constructor(key)
{
// Set node key
this.key = key;
// Create memory of TreeNode child
this.child = [];
}
addChild(key)
{
// Create a new node
var node = new TreeNode(key);
// Add node into child
this.child.push(node);
}
}
class NAryTree
{
constructor()
{
this.root = null;
}
printPostOrder(node)
{
if (node == null)
{
return;
}
for (var i = 0; i < node.child.length; ++i)
{
// Visit child node
this.printPostOrder(node.child[i]);
}
// Display node value
process.stdout.write(" " + node.key);
}
}
function main()
{
var tree = new NAryTree();
/*
10
/ \
/ \
/ \
8 5
/|\ /|\ \
/ | \ / | \ \
-2 1 6 7 18 3 4
/ \ /| \
9 11 2 1 3
/ \
17 12
-----------------------
Constructing N-Arr tree
*/
// First element of tree
tree.root = new TreeNode(10);
tree.root.addChild(8);
tree.root.addChild(5);
// Add child node [-2,1,6] in node (8)
tree.root.child[0].addChild(-2);
tree.root.child[0].addChild(1);
tree.root.child[0].addChild(6);
// Add child node [9,11] in node (1)
tree.root.child[0].child[1].addChild(9);
tree.root.child[0].child[1].addChild(11);
// Add child node [17 12] in node (11)
tree.root.child[0].child[1].child[1].addChild(17);
tree.root.child[0].child[1].child[1].addChild(12);
// Add child node [7 18 3 4] in node (5)
tree.root.child[1].addChild(7);
tree.root.child[1].addChild(18);
tree.root.child[1].addChild(3);
tree.root.child[1].addChild(4);
// Add child node [2,1,3] in node (4)
tree.root.child[1].child[3].addChild(2);
tree.root.child[1].child[3].addChild(1);
tree.root.child[1].child[3].addChild(3);
tree.printPostOrder(tree.root);
}
main();
Output
-2 9 17 12 11 1 6 8 7 18 3 2 1 3 4 5 10
# Python 3 program for
# Postorder traversal of an N-ary Tree
class TreeNode :
def __init__(self, key) :
# Set node key
self.key = key
# Create memory of TreeNode child
self.child = []
def addChild(self, key) :
# Create a new node
node = TreeNode(key)
# Add node into child
self.child.append(node)
class NAryTree :
def __init__(self) :
self.root = None
def printPostOrder(self, node) :
if (node == None) :
return
i = 0
while (i < len(node.child)) :
# Visit child node
self.printPostOrder(node.child[i])
i += 1
# Display node value
print(" ", node.key, end = "")
def main() :
tree = NAryTree()
# 10
# / \
# / \
# / \
# 8 5
# /|\ /|\ \
# / | \ / | \ \
# -2 1 6 7 18 3 4
# / \ /| \
# 9 11 2 1 3
# / \
# 17 12
# -----------------------
# Constructing N-Arr tree
# First element of tree
tree.root = TreeNode(10)
tree.root.addChild(8)
tree.root.addChild(5)
# Add child node [-2,1,6] in node (8)
tree.root.child[0].addChild(-2)
tree.root.child[0].addChild(1)
tree.root.child[0].addChild(6)
# Add child node [9,11] in node (1)
tree.root.child[0].child[1].addChild(9)
tree.root.child[0].child[1].addChild(11)
# Add child node [17 12] in node (11)
tree.root.child[0].child[1].child[1].addChild(17)
tree.root.child[0].child[1].child[1].addChild(12)
# Add child node [7 18 3 4] in node (5)
tree.root.child[1].addChild(7)
tree.root.child[1].addChild(18)
tree.root.child[1].addChild(3)
tree.root.child[1].addChild(4)
# Add child node [2,1,3] in node (4)
tree.root.child[1].child[3].addChild(2)
tree.root.child[1].child[3].addChild(1)
tree.root.child[1].child[3].addChild(3)
tree.printPostOrder(tree.root)
if __name__ == "__main__": main()
Output
-2 9 17 12 11 1 6 8 7 18 3 2 1 3 4 5 10
# Ruby program for
# Postorder traversal of an N-ary Tree
class TreeNode
# Define the accessor and reader of class TreeNode
attr_reader :key, :child
attr_accessor :key, :child
def initialize(key)
# Set node key
self.key = key
# Create memory of TreeNode child
self.child = []
end
def addChild(key)
# Create a new node
node = TreeNode.new(key)
# Add node into child
self.child.push(node)
end
end
class NAryTree
# Define the accessor and reader of class NAryTree
attr_reader :root
attr_accessor :root
def initialize()
self.root = nil
end
def printPostOrder(node)
if (node == nil)
return
end
i = 0
while (i < node.child.length)
# Visit child node
self.printPostOrder(node.child[i])
i += 1
end
# Display node value
print(" ", node.key)
end
end
def main()
tree = NAryTree.new()
# 10
# / \
# / \
# / \
# 8 5
# /|\ /|\ \
# / | \ / | \ \
# -2 1 6 7 18 3 4
# / \ /| \
# 9 11 2 1 3
# / \
# 17 12
# -----------------------
# Constructing N-Arr tree
# First element of tree
tree.root = TreeNode.new(10)
tree.root.addChild(8)
tree.root.addChild(5)
# Add child node [-2,1,6] in node (8)
tree.root.child[0].addChild(-2)
tree.root.child[0].addChild(1)
tree.root.child[0].addChild(6)
# Add child node [9,11] in node (1)
tree.root.child[0].child[1].addChild(9)
tree.root.child[0].child[1].addChild(11)
# Add child node [17 12] in node (11)
tree.root.child[0].child[1].child[1].addChild(17)
tree.root.child[0].child[1].child[1].addChild(12)
# Add child node [7 18 3 4] in node (5)
tree.root.child[1].addChild(7)
tree.root.child[1].addChild(18)
tree.root.child[1].addChild(3)
tree.root.child[1].addChild(4)
# Add child node [2,1,3] in node (4)
tree.root.child[1].child[3].addChild(2)
tree.root.child[1].child[3].addChild(1)
tree.root.child[1].child[3].addChild(3)
tree.printPostOrder(tree.root)
end
main()
Output
-2 9 17 12 11 1 6 8 7 18 3 2 1 3 4 5 10
import scala.collection.mutable._;
// Scala program for
// Postorder traversal of an N-ary Tree
class TreeNode(var key: Int,
var child: ArrayBuffer[TreeNode])
{
def this(key: Int)
{
// Set node key
// Create memory of TreeNode child
this(key, new ArrayBuffer[TreeNode]());
}
def addChild(key: Int): Unit = {
// Create a new node
var node: TreeNode = new TreeNode(key);
// Add node into child
this.child += node;
}
}
class NAryTree(var root: TreeNode)
{
def this()
{
this(null);
}
def printPostOrder(node: TreeNode): Unit = {
if (node == null)
{
return;
}
var i: Int = 0;
while (i < node.child.size)
{
// Visit child node
printPostOrder(node.child(i));
i += 1;
}
// Display node value
print(" " + node.key);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var tree: NAryTree = new NAryTree();
/*
10
/ \
/ \
/ \
8 5
/|\ /|\ \
/ | \ / | \ \
-2 1 6 7 18 3 4
/ \ /| \
9 11 2 1 3
/ \
17 12
-----------------------
Constructing N-Arr tree
*/
// First element of tree
tree.root = new TreeNode(10);
tree.root.addChild(8);
tree.root.addChild(5);
// Add child node [-2,1,6] in node (8)
tree.root.child(0).addChild(-2);
tree.root.child(0).addChild(1);
tree.root.child(0).addChild(6);
// Add child node [9,11] in node (1)
tree.root.child(0).child(1).addChild(9);
tree.root.child(0).child(1).addChild(11);
// Add child node [17 12] in node (11)
tree.root.child(0).child(1).child(1).addChild(17);
tree.root.child(0).child(1).child(1).addChild(12);
// Add child node [7 18 3 4] in node (5)
tree.root.child(1).addChild(7);
tree.root.child(1).addChild(18);
tree.root.child(1).addChild(3);
tree.root.child(1).addChild(4);
// Add child node [2,1,3] in node (4)
tree.root.child(1).child(3).addChild(2);
tree.root.child(1).child(3).addChild(1);
tree.root.child(1).child(3).addChild(3);
tree.printPostOrder(tree.root);
}
}
Output
-2 9 17 12 11 1 6 8 7 18 3 2 1 3 4 5 10
import Foundation;
// Swift 4 program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
var key: Int;
var child: [TreeNode? ];
init(_ key: Int)
{
// Set node key
self.key = key;
// Create memory of TreeNode child
self.child = [TreeNode? ]();
}
func addChild(_ key: Int)
{
// Create a new node
let node: TreeNode = TreeNode(key);
// Add node into child
self.child.append(node);
}
}
class NAryTree
{
var root: TreeNode? ;
init()
{
self.root = nil;
}
func printPostOrder(_ node: TreeNode? )
{
if (node == nil)
{
return;
}
var i: Int = 0;
while (i < node!.child.count)
{
// Visit child node
self.printPostOrder(node!.child[i]);
i += 1;
}
// Display node value
print(" ", node!.key, terminator: "");
}
}
func main()
{
let tree: NAryTree = NAryTree();
/*
10
/ \
/ \
/ \
8 5
/|\ /|\ \
/ | \ / | \ \
-2 1 6 7 18 3 4
/ \ /| \
9 11 2 1 3
/ \
17 12
-----------------------
Constructing N-Arr tree
*/
// First element of tree
tree.root = TreeNode(10);
tree.root!.addChild(8);
tree.root!.addChild(5);
// Add child node [-2,1,6] in node (8)
tree.root!.child[0]!.addChild(-2);
tree.root!.child[0]!.addChild(1);
tree.root!.child[0]!.addChild(6);
// Add child node [9,11] in node (1)
tree.root!.child[0]!.child[1]!.addChild(9);
tree.root!.child[0]!.child[1]!.addChild(11);
// Add child node [17 12] in node (11)
tree.root!.child[0]!.child[1]!.child[1]!.addChild(17);
tree.root!.child[0]!.child[1]!.child[1]!.addChild(12);
// Add child node [7 18 3 4] in node (5)
tree.root!.child[1]!.addChild(7);
tree.root!.child[1]!.addChild(18);
tree.root!.child[1]!.addChild(3);
tree.root!.child[1]!.addChild(4);
// Add child node [2,1,3] in node (4)
tree.root!.child[1]!.child[3]!.addChild(2);
tree.root!.child[1]!.child[3]!.addChild(1);
tree.root!.child[1]!.child[3]!.addChild(3);
tree.printPostOrder(tree.root);
}
main();
Output
-2 9 17 12 11 1 6 8 7 18 3 2 1 3 4 5 10
// Kotlin program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
var key: Int;
var child: MutableList < TreeNode > ;
constructor(key: Int)
{
// Set node key
this.key = key;
// Create memory of TreeNode child
this.child = mutableListOf < TreeNode > ();
}
fun addChild(key: Int): Unit
{
// Create a new node
val node: TreeNode = TreeNode(key);
// Add node into child
this.child.add(node);
}
}
class NAryTree
{
var root: TreeNode ? ;
constructor()
{
this.root = null;
}
fun printPostOrder(node: TreeNode ? ): Unit
{
if (node == null)
{
return;
}
var i: Int = 0;
while (i < node.child.size)
{
// Visit child node
this.printPostOrder(node.child[i]);
i += 1;
}
// Display node value
print(" " + node.key);
}
}
fun main(args: Array < String > ): Unit
{
val tree: NAryTree = NAryTree();
/*
10
/ \
/ \
/ \
8 5
/|\ /|\ \
/ | \ / | \ \
-2 1 6 7 18 3 4
/ \ /| \
9 11 2 1 3
/ \
17 12
-----------------------
Constructing N-Arr tree
*/
// First element of tree
tree.root = TreeNode(10);
tree.root?.addChild(8);
tree.root?.addChild(5);
// Add child node [-2,1,6] in node (8)
tree.root!!.child[0].addChild(-2);
tree.root!!.child[0].addChild(1);
tree.root!!.child[0].addChild(6);
// Add child node [9,11] in node (1)
tree.root!!.child[0].child[1].addChild(9);
tree.root!!.child[0].child[1].addChild(11);
// Add child node [17 12] in node (11)
tree.root!!.child[0].child[1].child[1].addChild(17);
tree.root!!.child[0].child[1].child[1].addChild(12);
// Add child node [7 18 3 4] in node (5)
tree.root!!.child[1].addChild(7);
tree.root!!.child[1].addChild(18);
tree.root!!.child[1].addChild(3);
tree.root!!.child[1].addChild(4);
// Add child node [2,1,3] in node (4)
tree.root!!.child[1].child[3].addChild(2);
tree.root!!.child[1].child[3].addChild(1);
tree.root!!.child[1].child[3].addChild(3);
tree.printPostOrder(tree.root);
}
Output
-2 9 17 12 11 1 6 8 7 18 3 2 1 3 4 5 10
Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.
New Comment