private static void GramToNdfaAndReverse()
{
char[] alphabet = { 'a', 'b' };
var ndfa = new Automaat <int>(alphabet);
ndfa.AddTransition(new Transition <int>(0, alphabet[0], 0));
ndfa.AddTransition(new Transition <int>(0, alphabet[0], 1));
ndfa.AddTransition(new Transition <int>(0, alphabet[1], 0));
ndfa.AddTransition(new Transition <int>(0, alphabet[1], 3));
ndfa.AddTransition(new Transition <int>(1, alphabet[0], 2));
ndfa.AddTransition(new Transition <int>(2, alphabet[0]));
ndfa.AddTransition(new Transition <int>(2, alphabet[1]));
ndfa.AddTransition(new Transition <int>(3, alphabet[1], 4));
ndfa.AddTransition(new Transition <int>(4, alphabet[0]));
ndfa.AddTransition(new Transition <int>(4, alphabet[1]));
ndfa.DefineAsStartState(0);
ndfa.DefineAsFinalState(2);
ndfa.DefineAsFinalState(4);
Graphviz.PrintGraph(ndfa, "ndfaToGram");
var gram = RegGram <int> .NdfaToRegGram(ndfa);
Console.WriteLine(gram.ToString());
}
private static Automaat <int> GetEvenBOrUnevenA()
{
char[] alphabet = { 'a', 'b' };
Automaat <int> m = new Automaat <int>(alphabet);
m.AddTransition(new Transition <int>(1, alphabet[0], 2));
m.AddTransition(new Transition <int>(1, alphabet[1], 3));
m.AddTransition(new Transition <int>(2, alphabet[0], 1));
m.AddTransition(new Transition <int>(2, alphabet[1], 5));
m.AddTransition(new Transition <int>(3, alphabet[0], 2));
m.AddTransition(new Transition <int>(3, alphabet[1], 4));
m.AddTransition(new Transition <int>(4, alphabet[0], 2));
m.AddTransition(new Transition <int>(4, alphabet[1], 4));
m.AddTransition(new Transition <int>(5, alphabet[0], 1));
m.AddTransition(new Transition <int>(5, alphabet[1], 4));
// only on start state in a dfa:
m.DefineAsStartState(1);
// two final states:
m.DefineAsFinalState(2);
m.DefineAsFinalState(4);
m.DefineAsFinalState(5);
return(m);
}
private static Automaat <int> GetStartAbbOrEndBaab()
{
char[] alphabet = { 'a', 'b' };
Automaat <int> m = new Automaat <int>(alphabet);
m.AddTransition(new Transition <int>(1, 'a', 2));
m.AddTransition(new Transition <int>(1, 'b', 5));
m.AddTransition(new Transition <int>(2, 'a', 9));
m.AddTransition(new Transition <int>(2, 'b', 3));
m.AddTransition(new Transition <int>(3, 'a', 6));
m.AddTransition(new Transition <int>(3, 'b', 4));
m.AddTransition(new Transition <int>(4, 'a', 4));
m.AddTransition(new Transition <int>(4, 'b', 4));
m.AddTransition(new Transition <int>(5, 'a', 6));
m.AddTransition(new Transition <int>(5, 'b', 5));
m.AddTransition(new Transition <int>(6, 'a', 7));
m.AddTransition(new Transition <int>(6, 'b', 5));
m.AddTransition(new Transition <int>(7, 'a', 9));
m.AddTransition(new Transition <int>(7, 'b', 8));
m.AddTransition(new Transition <int>(8, 'a', 6));
m.AddTransition(new Transition <int>(8, 'b', 5));
m.AddTransition(new Transition <int>(9, 'a', 9));
m.AddTransition(new Transition <int>(9, 'b', 5));
m.DefineAsStartState(1);
m.DefineAsFinalState(4);
m.DefineAsFinalState(8);
return(m);
}
private void HandleSubMenu(int index, Automaat <int> automaat)
{
switch (index)
{
case 0:
automaat.ViewImage();
break;
case 1:
NdfatoDfa.MakeDfa(automaat).ViewImage();
break;
case 2:
automaat.MinimizeHopCroft(false).ViewImage();
break;
case 3:
automaat.GeefTaal(5).ForEach(s => Console.WriteLine(s));
Console.ReadLine();
break;
case 4:
automaat.GeefNietTaal(5).ForEach(s => Console.WriteLine(s));
Console.ReadLine();
break;
}
}
private static void FindNextState(ref Automaat <State> a, ref int counter, Automaat <T> a1, Automaat <T> a2, State s)
{
foreach (var c in a.GetAlphabet())
{
var a1State = a1.GetTransitions(s.StateAutomaat1, c).First().ToState;
var a2State = a2.GetTransitions(s.StateAutomaat2, c).First().ToState;
var newState = default(State);
var stateExsists = false;
foreach (var state in a._states)
{
if (!state.HaseSameStates(a1State, a2State))
{
continue;
}
newState = state;
stateExsists = true;
break;
}
if (!stateExsists)
{
newState = new State(++counter, a1State, a2State);
a.AddTransition(new Transition <State>(s, c, newState));
FindNextState(ref a, ref counter, a1, a2, newState);
}
else
{
a.AddTransition(new Transition <State>(s, c, newState));
}
}
}
public static SortedSet <T> FindToStates <T>(ref SortedSet <T> toStates, Automaat <T> ndfa, T state, char symbol) where T : IComparable
{
var transitions = ndfa.GetTransitions(state, symbol);
foreach (var trans in transitions)
{
if (trans.IsEpsilonTransition())
{
if (symbol == Transition <T> .Epsilon)
{
toStates.Add(trans.ToState);
FindToStates(ref toStates, ndfa, trans.ToState, Transition <T> .Epsilon);
}
else
{
FindToStates(ref toStates, ndfa, trans.ToState, symbol);
}
}
else
{
toStates.Add(trans.ToState);
FindToStates(ref toStates, ndfa, trans.ToState, Transition <T> .Epsilon);
}
}
return(toStates);
}
public Automaat <int> ToAutomaat()
{
var automaat = new Automaat <int>(Alphabet);
foreach (var block in Blocks)
{
foreach (char c in Alphabet)
{
if (block.Rows.Count > 0)
{
automaat.AddTransition(new Transition <int>(block.Identifier, c, block.Rows[0].FindDestination(c).Identifier));
}
}
Automaat._startStates.ToList().ForEach(startstate =>
{
block.States.ToList().ForEach(state =>
{
if (state.Equals(startstate))
{
automaat.DefineAsStartState(block.Identifier);
}
});
});
if (block.isFinalState)
{
automaat.DefineAsFinalState(block.Identifier);
}
}
return(automaat);
}
public static void PrintGraph <T>(Automaat <T> data, string filename) where T : IComparable
{
var s = "digraph{ ";
s += GetFinalStatesData(data);
s += GetStartStatesData(data);
s += "node [shape = circle];";
foreach (var t in data._transitions)
{
//s += " " + ("S" + t.FromState) + " -> " + ("S" + t.ToState) + " " + "[ label = " + "\"" + t.Symbol + "\"" + " ];";
if (t.Symbol.Equals('$'))
{
s += $" S{t.FromState} -> S{t.ToState} [ label = \"{t.Symbol}\" ]; ";
}
else
{
s += $" S{t.FromState} -> S{t.ToState} [ label = {t.Symbol} ]; ";
}
}
s += " }";
//Console.WriteLine(s);
GenerateGraphFile(s, filename);
}
public Table(Automaat <int> automaat)
{
Automaat = automaat;
automaat._symbols.ToList().ForEach(s => Alphabet.Add(s));
InitBlocks();
Blocks.ForEach(b => b.FindDestinations());
}
public static void Regel1En2(RegExp reg, ref Automaat <int> a, ref int c, int leftState, int rightState)
{
var symbol = reg.terminals.First();
a._symbols.Add(symbol);
a.AddTransition(new Transition <int>(leftState, symbol, rightState));
}
private static void ModifyAutomaat(RegExp reg, ref Automaat <int> a, ref int c, int leftState, int rightState)
{
switch (reg._operator)
{
case RegExp.Operator.PLUS:
Regel5(reg, ref a, ref c, leftState, rightState);
break;
case RegExp.Operator.STAR:
Regel6(reg, ref a, ref c, leftState, rightState);
break;
case RegExp.Operator.OR:
Regel4(reg, ref a, ref c, leftState, rightState);
break;
case RegExp.Operator.DOT:
Regel3(reg, ref a, ref c, leftState, rightState);
break;
case RegExp.Operator.ONE:
Regel1En2(reg, ref a, ref c, leftState, rightState);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
static void testEpsilonNDFA()
{
char[] alphabet = { 'a', 'b' };
var m = new Automaat <string>(alphabet);
m.AddTransition(new Transition <string>("1", alphabet[0], "1"));
m.AddTransition(new Transition <string>("1", alphabet[0], "2"));
m.AddTransition(new Transition <string>("1", Transition <string> .Epsilon, "3"));
m.AddTransition(new Transition <string>("2", alphabet[1], "4"));
m.AddTransition(new Transition <string>("3", alphabet[1], "5"));
m.DefineAsStartState("1");
m.DefineAsFinalState("5");
//woord bevat 1 b en eindigt op 1 b
var testWords = new List <Tuple <string, bool> >();
testWords.Add(new Tuple <string, bool>("b", true));
testWords.Add(new Tuple <string, bool>("ab", true));
testWords.Add(new Tuple <string, bool>("a", false));
testWords.Add(new Tuple <string, bool>("bba", false));
testWords.Add(new Tuple <string, bool>("aaab", true));
//TestingAutomaat("Testing for epsilon transitions", m, testWords);
var dfa = NdfatoDfa.MakeDfa(m);
dfa.PrintTransitions();
TestingAutomaat("Testing for epsilon transitions", dfa, testWords);
}
static void Ndfa()
{
char[] alphabet = { 'a', 'b' };
Automaat <string> m = new Automaat <string>(alphabet);
m.AddTransition(new Transition <string>("1", alphabet[0], "2"));
m.AddTransition(new Transition <string>("1", alphabet[0], "3"));
m.AddTransition(new Transition <string>("1", alphabet[1], "1"));
m.AddTransition(new Transition <string>("2", alphabet[0], "2"));
m.AddTransition(new Transition <string>("2", alphabet[1], "2"));
m.AddTransition(new Transition <string>("3", alphabet[0], "2"));
m.AddTransition(new Transition <string>("3", alphabet[1], "4"));
m.AddTransition(new Transition <string>("4", alphabet[0], "2"));
m.AddTransition(new Transition <string>("4", alphabet[1], "2"));
// only on start state in a dfa:
m.DefineAsStartState("1");
// two final states:
m.DefineAsFinalState("4");
var testWords = new List <Tuple <string, bool> >();
testWords.Add(new Tuple <string, bool>("ab", true));
testWords.Add(new Tuple <string, bool>("ba", false));
testWords.Add(new Tuple <string, bool>("aa", false));
testWords.Add(new Tuple <string, bool>("bbab", true));
TestingAutomaat("testing code for ndfa", m, testWords);
}
public Block(Table table, List <Row> rows, int id)
{
this.table = table;
this.automaat = table.Automaat;
this.Identifier = id;
this.Rows = rows;
rows.ForEach(r => States.Add(r.State));
}
public static void Regel3(RegExp reg, ref Automaat <int> a, ref int c, int leftState, int rightState)
{
var newState = c + 1;
c = newState;
ModifyAutomaat(reg.left, ref a, ref c, leftState, newState);
ModifyAutomaat(reg.right, ref a, ref c, newState, rightState);
}
public Automaat <T> Reverse()
{
var reversedAutomaat = new Automaat <T>(_symbols);
_startStates.ToList().ForEach(state => reversedAutomaat.DefineAsFinalState(state));
_finalStates.ToList().ForEach(state => reversedAutomaat.DefineAsStartState(state));
_transitions.ToList().ForEach(trans => reversedAutomaat.AddTransition(trans.Reverse()));
return(reversedAutomaat);
}
private static Automaat <int> EindigtOp(string rulesymbols, char[] alphabet)
{
var a = new Automaat <int>(alphabet);
var stateCounter = 0;
var startState = ++stateCounter;
var fromState = startState;
a.DefineAsStartState(fromState);
var word = "";
foreach (var s in rulesymbols.ToCharArray())
{
stateCounter++;
word += s;
foreach (var letter in a.GetAlphabet())
{
if (s == letter)
{
a.AddTransition(new Transition <int>(fromState, s, stateCounter));
}
else
{
int i;
for (i = 0; i < word.Length; i++)
{
if (word[i] != letter)
{
break;
}
}
a.AddTransition(new Transition <int>(fromState, letter, i + startState));
}
}
fromState = stateCounter;
}
foreach (var letter in a.GetAlphabet())
{
int i;
for (i = 0; i < rulesymbols.Length; i++)
{
if (word[i] != letter)
{
break;
}
}
a.AddTransition(new Transition <int>(fromState, letter, i + startState));
}
a.DefineAsFinalState(stateCounter);
return(a);
}
public Block(Table table, SortedSet <int> states, int id)
{
this.table = table;
this.automaat = table.Automaat;
this.Identifier = id;
this.States = states;
var rowId = 0;
states.ToList().ForEach(x => { Rows.Add(new Row(table, x, rowId)); rowId++; });
}
public static void Regel5(RegExp reg, ref Automaat <int> a, ref int c, int leftState, int rightState)
{
var newLeftState = c + 1;
var newRightState = newLeftState + 1;
c = newRightState;
a.AddTransition(new Transition <int>(leftState, Transition <int> .Epsilon, newLeftState));
a.AddTransition(new Transition <int>(newRightState, Transition <int> .Epsilon, rightState));
a.AddTransition(new Transition <int>(newRightState, Transition <int> .Epsilon, newLeftState));
ModifyAutomaat(reg.left, ref a, ref c, newLeftState, newRightState);
}
static void PracL1ERepresentatie1()
{
/*begint met abb of eindigt op baab*/
char[] alphabet = { 'a', 'b' };
Automaat <string> m = new Automaat <string>(alphabet);
m.AddTransition(new Transition <string>("1", 'a', "2"));
m.AddTransition(new Transition <string>("1", 'b', "5"));
m.AddTransition(new Transition <string>("2", 'a', "9"));
m.AddTransition(new Transition <string>("2", 'b', "3"));
m.AddTransition(new Transition <string>("3", 'a', "6"));
m.AddTransition(new Transition <string>("3", 'b', "4"));
m.AddTransition(new Transition <string>("4", 'a', "4"));
m.AddTransition(new Transition <string>("4", 'b', "4"));
m.AddTransition(new Transition <string>("5", 'a', "6"));
m.AddTransition(new Transition <string>("5", 'b', "5"));
m.AddTransition(new Transition <string>("6", 'a', "7"));
m.AddTransition(new Transition <string>("6", 'b', "5"));
m.AddTransition(new Transition <string>("7", 'a', "9"));
m.AddTransition(new Transition <string>("7", 'b', "8"));
m.AddTransition(new Transition <string>("8", 'a', "6"));
m.AddTransition(new Transition <string>("8", 'b', "5"));
m.AddTransition(new Transition <string>("9", 'a', "9"));
m.AddTransition(new Transition <string>("9", 'b', "5"));
// only on start state in a dfa:
m.DefineAsStartState("1");
// two final states:
m.DefineAsFinalState("4");
m.DefineAsFinalState("8");
List <Tuple <string, bool> > testWords = new List <Tuple <string, bool> >();
testWords.Add(new Tuple <string, bool>("abb", true));
testWords.Add(new Tuple <string, bool>("baab", true));
testWords.Add(new Tuple <string, bool>("aabb", false));
testWords.Add(new Tuple <string, bool>("ab", false));
testWords.Add(new Tuple <string, bool>("baa", false));
testWords.Add(new Tuple <string, bool>("aabbabaaabaab", true));
testWords.Add(new Tuple <string, bool>("ababaabaa", false));
testWords.Add(new Tuple <string, bool>("abba", true));
TestingAutomaat("Begint met abb of eindigt op baab", m, testWords);
}
public static Automaat <int> CreateAutomaat(RegExp reg)
{
var automaat = new Automaat <int>();
int stateCounter = 1, leftState = 0, rightState = 1;
automaat.DefineAsStartState(leftState);
automaat.DefineAsFinalState(rightState);
ModifyAutomaat(reg, ref automaat, ref stateCounter, leftState, rightState);
return(automaat);
}
private static Automaat <int> GetStartWithABB()
{
var a1 = new Automaat <int>(alphabet);
a1.AddTransition(new Transition <int>(0, alphabet[0], 1));
a1.AddTransition(new Transition <int>(1, alphabet[1], 2));
a1.AddTransition(new Transition <int>(2, alphabet[1], 3));
a1.AddTransition(new Transition <int>(3, alphabet[0], 3));
a1.AddTransition(new Transition <int>(3, alphabet[1], 3));
a1.DefineAsStartState(0);
a1.DefineAsFinalState(3);
return(a1);
}
static void PracL1Representatie2()
{
char[] alphabet = { 'a', 'b' };
Automaat <string> m = new Automaat <string>(alphabet);
m.AddTransition(new Transition <string>("1", alphabet[0], "2"));
m.AddTransition(new Transition <string>("1", alphabet[1], "3"));
m.AddTransition(new Transition <string>("2", alphabet[0], "1"));
m.AddTransition(new Transition <string>("2", alphabet[1], "5"));
m.AddTransition(new Transition <string>("3", alphabet[0], "2"));
m.AddTransition(new Transition <string>("3", alphabet[1], "4"));
m.AddTransition(new Transition <string>("4", alphabet[0], "2"));
m.AddTransition(new Transition <string>("4", alphabet[1], "4"));
m.AddTransition(new Transition <string>("5", alphabet[0], "1"));
m.AddTransition(new Transition <string>("5", alphabet[1], "4"));
// only on start state in a dfa:
m.DefineAsStartState("1");
// two final states:
m.DefineAsFinalState("2");
m.DefineAsFinalState("4");
m.DefineAsFinalState("5");
List <Tuple <string, bool> > testWords = new List <Tuple <string, bool> >();
testWords.Add(new Tuple <string, bool>("a", true));
testWords.Add(new Tuple <string, bool>("bb", true));
testWords.Add(new Tuple <string, bool>("abb", true));
testWords.Add(new Tuple <string, bool>("aabb", true));
testWords.Add(new Tuple <string, bool>("baa", false));
testWords.Add(new Tuple <string, bool>("aabbabaaabab", true));
testWords.Add(new Tuple <string, bool>("ababaabaa", false));
testWords.Add(new Tuple <string, bool>("abba", true));
testWords.Add(new Tuple <string, bool>("babab", false));
testWords.Add(new Tuple <string, bool>("ababa", true));
TestingAutomaat("Bevat een even aantal b’s of bevat een oneven aantal a’s", m, testWords);
var a = m.GeefTaal(3);
Console.WriteLine("geaccepteerde woorden:");
a.ForEach(word => Console.WriteLine("\t" + word));
var b = m.GeefNietTaal(3);
Console.WriteLine("niew geaccepteerde woorden:");
b.ForEach(word => Console.WriteLine("\t" + word));
}
static void TestSamenvoegen()
{
char[] alphabet = { 'a', 'b' };
var dfa1 = new Automaat <int>(alphabet);
dfa1.AddTransition(new Transition <int>(1, alphabet[0], 2));
dfa1.AddTransition(new Transition <int>(1, alphabet[1], 1));
dfa1.AddTransition(new Transition <int>(2, alphabet[0], 1));
dfa1.AddTransition(new Transition <int>(2, alphabet[1], 2));
dfa1.DefineAsStartState(1);
dfa1.DefineAsFinalState(1);
var dfa2 = new Automaat <int>(alphabet);
dfa2.AddTransition(new Transition <int>(1, alphabet[0], 1));
dfa2.AddTransition(new Transition <int>(1, alphabet[1], 2));
dfa2.AddTransition(new Transition <int>(2, alphabet[0], 1));
dfa2.AddTransition(new Transition <int>(2, alphabet[1], 3));
dfa2.AddTransition(new Transition <int>(3, alphabet[0], 1));
dfa2.AddTransition(new Transition <int>(3, alphabet[1], 4));
dfa2.AddTransition(new Transition <int>(4, alphabet[0], 4));
dfa2.AddTransition(new Transition <int>(4, alphabet[1], 4));
dfa2.DefineAsStartState(1);
dfa2.DefineAsFinalState(1);
dfa2.DefineAsFinalState(2);
var notDfa1 = !dfa1;
var notDfa2 = !dfa2;
var and = dfa1 & dfa2;
var or = dfa1 | dfa2;
Graphviz.PrintGraph(and, "and");
var testWords = new List <Tuple <string, bool> >();
dfa1.GeefTaal(4).ForEach(s => testWords.Add(new Tuple <string, bool>(s, true)));
dfa2.GeefTaal(4).ForEach(s => testWords.Add(new Tuple <string, bool>(s, true)));
TestingAutomaat("And dfa", and, testWords);
TestingAutomaat("Or dfa", or, testWords);
}
private static SortedSet <Tuple <T, char, SortedSet <T> > > MakeTable <T>(Automaat <T> ndfa) where T : IComparable
{
var table = new SortedSet <Tuple <T, char, SortedSet <T> > >();
foreach (var state in ndfa._states)
{
foreach (var symbol in ndfa._symbols)
{
var listOfToStates = new SortedSet <T>();
FindToStates(ref listOfToStates, ndfa, state, symbol);
table.Add(new Tuple <T, char, SortedSet <T> >(state, symbol, listOfToStates));
}
}
return(table);
}
private static Automaat <int> GetEndWithABB()
{
var a1 = new Automaat <int>(alphabet);
a1.AddTransition(new Transition <int>(0, Transition <int> .Epsilon, 1)); a1.AddTransition(new Transition <int>(0, Transition <int> .Epsilon, 7));
a1.AddTransition(new Transition <int>(1, Transition <int> .Epsilon, 2)); a1.AddTransition(new Transition <int>(1, Transition <int> .Epsilon, 4));
a1.AddTransition(new Transition <int>(2, alphabet[0], 3)); a1.AddTransition(new Transition <int>(3, Transition <int> .Epsilon, 6));
a1.AddTransition(new Transition <int>(4, alphabet[1], 5)); a1.AddTransition(new Transition <int>(5, Transition <int> .Epsilon, 6));
a1.AddTransition(new Transition <int>(6, Transition <int> .Epsilon, 7)); a1.AddTransition(new Transition <int>(7, alphabet[0], 8));
a1.AddTransition(new Transition <int>(6, Transition <int> .Epsilon, 1)); a1.AddTransition(new Transition <int>(8, alphabet[1], 9));
a1.AddTransition(new Transition <int>(9, alphabet[1], 10));
a1.DefineAsStartState(0);
a1.DefineAsFinalState(10);
return(a1);
}
private void BuildAutomaat(string ruleint, string alphabetint, int typeIndex)
{
var a = new SortedSet <char>(alphabetint);
ruleint.ToCharArray().ToList().ForEach(c => a.Add(c));
char[] alphabet = new char[a.Count];
for (int i = 0; i < a.Count; i++)
{
alphabet[i] = a.ElementAt(i);
}
var type = (AutomaatGenerator.AutomaatType)_types.GetValue(typeIndex);
this._buildedAutomaat =
AutomaatGenerator.GenerateAutomaat(ruleint, alphabet, type);
}
private static Automaat <State> BetweenAutomaat(Automaat <T> a1, Automaat <T> a2)
{
var alphabet = new SortedSet <char>(a1.GetAlphabet());
a2.GetAlphabet().ToList().ForEach(c => alphabet.Add(c));
var newA = new Automaat <State>(alphabet);
var stateCounter = 0;
var beginState = new State(stateCounter, a1._startStates.First(), a2._startStates.First());
newA.DefineAsStartState(beginState);
FindNextState(ref newA, ref stateCounter, a1, a2, beginState);
return(newA);
}
private static string GetFinalStatesData <T>(Automaat <T> a) where T : IComparable
{
if (a._finalStates.Count == 0)
{
return("");
}
var s = "node [shape = doublecircle];";
foreach (var t in a._finalStates)
{
s += " " + ("S" + t) + " ";
}
s += "; ";
return(s);
}
static void TestingAutomaat <T>(string automaat_name, Automaat <T> a, List <Tuple <string, bool> > testWords) where T : IComparable
{
Console.WriteLine($"Testing automaat class, {automaat_name}");
Console.WriteLine("Automaat is a DFA: " + a.IsDfa());
foreach (Tuple <string, bool> word in testWords)
{
var geaccepteerd = a.Accepteer(word.Item1);
Console.WriteLine($"Word: is {word.Item1} accepted?, expected: {word.Item2}, result: {geaccepteerd}");
if (word.Item2 != geaccepteerd)
{
Console.WriteLine("Niet verwachte resultaat");
}
Console.WriteLine("----------");
}
Console.WriteLine();
}
