#
# Copyright 2014 Open Networking Laboratory
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
welcome = Welcome to Open Network Operating System (ONOS)!\r\n\
\u001B[1;31m     ____  _  ______  ____   \u001B[0m\r\n\
\u001B[1;31m    / __ \\/ |/ / __ \\/ __/    \u001B[0m\r\n\
\u001B[1;31m   / /_/ /    / /_/ /\\ \\       \u001B[0m\r\n\
\u001B[1;31m   \\____/_/|_/\\____/___/      \u001B[0m\r\n\
\u001B[1;31m                             \u001B[0m\r\n\
  \r\n\
  Hit '\u001B[1m<tab>\u001B[0m' for a list of available commands\r\n\
     and '\u001B[1m[cmd] --help\u001B[0m' for help on a specific command.\r\n\
  Hit '\u001B[1m<ctrl-d>\u001B[0m' or type '\u001B[1msystem:shutdown\u001B[0m' or '\u001B[1mlogout\u001B[0m' to shutdown ONOS.\r\n
prompt = \u001B[32monos> \u001B[0m
