#
# 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\
Documentation: wiki.onosproject.org      \r\n\
Tutorials:     tutorials.onosproject.org \r\n\
Mailing lists: lists.onosproject.org     \r\n\
\r\n\
Come help out! Find out how at: contribute.onosproject.org \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
