text:
from __future__ import print_function
import sys
import getopt
import re
import string
from jsbeautifier.__version__ import __version__

#
# The MIT License (MIT)

# Copyright (c) 2007-2013 Einar Lielmanis and contributors.

# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:

# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# Originally written by Einar Lielmanis et al.,
# Conversion to python by Einar Lielmanis, einar@jsbeautifier.org,
# Parsing improvement for brace-less and semicolon-less statements
#    by Liam Newman <bitwiseman@gmail.com>
# Python is not my native language, feel free to push things around.
#
# Use either from command line (script displays its usage when run
# without any parameters),
#
#
# or, alternatively, use it as a module:
#
#   import jsbeautifier
#   res = jsbeautifier.beautify('your javascript string')
#   res = jsbeautifier.beautify_file('some_file.js')
#
#  you may specify some options:
#
#   opts = jsbeautifier.default_options()
#   opts.indent_size = 2
#   res = jsbeautifier.beautify('some javascript', opts)
#
#
# Here are the available options: (read source)

class BeautifierOptions:
    def __init__(self):
        self.indent_size = 4
        self.indent_char = ' '
        self.indent_with_tabs = False
        self.preserve_newlines = True
        self.max_preserve_newlines = 10
        self.space_in_paren = False
        self.e4x = False
        self.jslint_happy = False
        self.brace_style = 'collapse'
        self.keep_array_indentation = False
        self.keep_function_indentation = False
        self.eval_code = False
        self.unescape_strings = False
        self.wrap_line_length = 0
        self.break_chained_methods = False

    def __repr__(self):
        return \
"""indent_size = %d
indent_char = [%s]
preserve_newlines = %s
max_preserve_newlines = %d
space_in_paren = %s
jslint_happy = %s
indent_with_tabs = %s
brace_style = %s
keep_array_indentation = %s
eval_code = %s
wrap_line_length = %s
unescape_strings = %s
""" % ( self.indent_size,
        self.indent_char,
        self.preserve_newlines,
        self.max_preserve_newlines,
        self.space_in_paren,
        self.jslint_happy,
        self.indent_with_tabs,
        self.brace_style,
        self.keep_array_indentation,
        self.eval_code,
        self.wrap_line_length,
        self.unescape_strings,
        )

class BeautifierFlags:
    def __init__(self, mode):
        self.mode = mode
        self.last_text = ''
        self.last_word = ''
        self.var_line = False
        self.var_line_tainted = False
        self.var_line_reindented = False
        self.in_html_comment = False
        self.multiline_array = False
        self.if_block = False
        self.do_block = False
        self.do_while = False
        self.in_case = False
        self.in_case_statement = False
        self.case_body = False
        self.indentation_level = 0
        self.ternary_depth = 0

    def apply_base(self, flags_base):
        self.last_text = flags_base.last_text
        self.last_word = flags_base.last_word
        self.indentation_level = flags_base.indentation_level

        if flags_base.var_line and flags_base.var_line_reindented:
            self.indentation_level += 1

def default_options():
    return BeautifierOptions()

def beautify(string, opts = default_options() ):
    b = Beautifier()
    return b.beautify(string, opts)

def beautify_file(file_name, opts = default_options() ):
    if file_name == '-': # stdin
        stream = sys.stdin
    else:
        stream = open(file_name)

    return beautify(''.join(stream.readlines()), opts);

def usage(stream=sys.stdout):

    print("jsbeautifier.py@" + __version__ + """

Javascript beautifier (http://jsbeautifier.org/)

Usage: jsbeautifier.py [options] <infile>

    <infile> can be "-", which means stdin.
    <outfile> defaults to stdout

Input options:

 -i,  --stdin                      read input from stdin

Output options:

 -s,  --indent-size=NUMBER         indentation size. (default 4).
 -c,  --indent-char=CHAR           character to indent with. (default space).
 -t,  --indent-with-tabs           Indent with tabs, overrides -s and -c
 -d,  --disable-preserve-newlines  do not preserve existing line breaks.
 -P,  --space-in-paren             add padding spaces within paren, ie. f( a, b )
 -j,  --jslint-happy               more jslint-compatible output
 -b,  --brace-style=collapse       brace style (collapse, expand, end-expand)
 -k,  --keep-array-indentation     keep array indentation.
 -o,  --outfile=FILE               specify a file to output to (default stdout)
 -f,  --keep-function-indentation  Do not re-indent function bodies defined in var lines.
 -x,  --unescape-strings           Decode printable chars encoded in \\xNN notation.
 -X,  --e4x                        Pass E4X xml literals through untouched
 -w,  --wrap-line-length                   Attempt to wrap line when it exceeds this length.
                                   NOTE: Line continues until next wrap point is found.

Rarely needed options:

 --eval-code                       evaluate code if a JS interpreter is
                                   installed. May be useful with some obfuscated
                                   script but poses a potential security issue.

 -l,  --indent-level=NUMBER        initial indentation level. (default 0).

 -h,  --help, --usage              prints this help statement.
 -v, --version                     Show the version

""", file=stream)
    if stream == sys.stderr:
        return 1
    else:
        return 0

class MODE:
      BlockStatement, Statement, ObjectLiteral, ArrayLiteral, \
      ForInitializer, Conditional, Expression = range(7)

class Beautifier:

    def __init__(self, opts = default_options() ):

        self.opts = opts
        self.blank_state()

    def blank_state(self):

        # internal flags
        self.flags = None
        self.previous_flags = None
        self.flag_store = []
        self.input_wanted_newline = False

        if self.opts.indent_with_tabs:
            self.indent_string = "\t"
        else:
            self.indent_string = self.opts.indent_char * self.opts.indent_size

        self.preindent_string = ''
        self.last_type = 'TK_START_EXPR' # last token type
        self.last_last_text = ''         # pre-last token text

        self.input = None
        self.dot_after_newline = False
        self.output = []                 # formatted javascript gets built here
        self.output_wrapped = False
        self.output_space_before_token = False
        self.whitespace_before_token = []

        self.whitespace = ["\n", "\r", "\t", " "]
        self.wordchar = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$'
        self.digits = '0123456789'
        self.punct = '+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! !! , : ? ^ ^= |= ::'
        self.punct += ' <?= <? ?> <%= <% %>'
        self.punct = self.punct.split(' ')

        # Words which always should start on a new line
        self.line_starters = 'continue,try,throw,return,var,if,switch,case,default,for,while,break,function'.split(',')

        self.set_mode(MODE.BlockStatement)

        self.parser_pos = 0

    def beautify(self, s, opts = None ):

        if opts != None:
            self.opts = opts

        if self.opts.brace_style not in ['expand', 'collapse', 'end-expand']:
            raise(Exception('opts.brace_style must be "expand", "collapse" or "end-expand".'))

        self.blank_state()

        while s and s[0] in [' ', '\t']:
            self.preindent_string += s[0]
            s = s[1:]

        self.input = self.unpack(s, self.opts.eval_code)

        self.parser_pos = 0
        handlers = {
            'TK_START_EXPR': self.handle_start_expr,
            'TK_END_EXPR': self.handle_end_expr,
            'TK_START_BLOCK': self.handle_start_block,
            'TK_END_BLOCK': self.handle_end_block,
            'TK_WORD': self.handle_word,
            'TK_SEMICOLON': self.handle_semicolon,
            'TK_STRING': self.handle_string,
            'TK_EQUALS': self.handle_equals,
            'TK_OPERATOR': self.handle_operator,
            'TK_COMMA': self.handle_comma,
            'TK_BLOCK_COMMENT': self.handle_block_comment,
            'TK_INLINE_COMMENT': self.handle_inline_comment,
            'TK_COMMENT': self.handle_comment,
            'TK_DOT': self.handle_dot,
            'TK_UNKNOWN': self.handle_unknown,
        }

        while True:
            self.token_text, token_type = self.get_next_token()

            #print (token_text, token_type, self.flags.mode)
            if token_type == 'TK_EOF':
                break

            keep_whitespace = self.opts.keep_array_indentation and self.is_array(self.flags.mode)

            if keep_whitespace:
                 for i in range(self.n_newlines):
                        self.append_newline(force_newline = True)
            else: # not keep_whitespace
                self.input_wanted_newline = self.n_newlines > 0
                if self.opts.max_preserve_newlines != 0 and self.n_newlines > self.opts.max_preserve_newlines:
                    self.n_newlines = self.opts.max_preserve_newlines

                if self.opts.preserve_newlines and self.n_newlines > 1:
                    for i in range(self.n_newlines):
                        self.append_newline(i != 0)

            handlers[token_type](self.token_text)

            # The cleanest handling of inline comments is to treat them as though they aren't there.
            # Just continue formatting and the behavior should be logical.
            if token_type != 'TK_INLINE_COMMENT' and token_type != 'TK_COMMENT' and token_type != 'TK_UNKNOWN':
                self.last_last_text = self.flags.last_text
                self.last_type = token_type
                self.flags.last_text = self.token_text

        sweet_code = self.preindent_string + re.sub('[\n ]+$', '', ''.join(self.output))
        return sweet_code

    def unpack(self, source, evalcode=False):
        import jsbeautifier.unpackers as unpackers
        try:
            return unpackers.run(source, evalcode)
        except unpackers.UnpackingError as error:
            print('error:', error)
            return ''

    def trim_output(self, eat_newlines = False):
        while len(self.output) \
              and (
                  self.output[-1] == ' '\
                  or self.output[-1] == self.indent_string \
                  or self.output[-1] == self.preindent_string \
                  or (eat_newlines and self.output[-1] in ['\n', '\r'])):
            self.output.pop()

    def is_special_word(self, s):
        return s in ['case', 'return', 'do', 'if', 'throw', 'else']

    def is_array(self, mode):
        return mode == MODE.ArrayLiteral

    def is_expression(self, mode):
        return mode in [MODE.Expression, MODE.ForInitializer, MODE.Conditional]

    def just_added_newline(self):
        return len(self.output) and self.output[-1] == '\n'

    def just_added_blankline(self):
        return self.just_added_newline() and len(self.output) - 1 > 0 and self.output[-2] == '\n'

    def last_index(self, arr, find):
        last_index = len(arr) - 1
        while last_index >= 0:
            if arr[last_index] == find:
                break
            else:
                last_index -= 1

        return last_index

    def allow_wrap_or_preserved_newline(self, token_text, force_linewrap = False):
        if self.opts.wrap_line_length > 0 and not force_linewrap:
            start_line = self.last_index(self.output, '\n') + 1

            # never wrap the first token of a line.
            if start_line < len(self.output):
                current_line = ''.join(self.output[start_line:])
                proposed_line_length = len(current_line) + len(token_text)
                if self.output_space_before_token:
                    proposed_line_length += 1

                if proposed_line_length >= self.opts.wrap_line_length:
                    force_linewrap = True

        if ((self.opts.preserve_newlines and self.input_wanted_newline) or force_linewrap) and not self.just_added_newline():
            self.append_newline(preserve_statement_flags = True)
            self.output_wrapped = True
            self.input_wanted_newline = False

    def append_newline(self, force_newline = False, preserve_statement_flags = False):
        self.output_wrapped = False
        self.output_space_before_token = False

        if not preserve_statement_flags:
            if self.flags.last_text != ';':
                while self.flags.mode == MODE.Statement and not self.flags.if_block:
                    self.restore_mode();

        if self.flags.mode == MODE.ArrayLiteral:
            self.flags.multiline_array = True

        if len(self.output) == 0:
            # no newline on start of file
            return

        if force_newline or not self.just_added_newline():
            self.output.append('\n')

    def append_token_line_indentation(self):
        if self.just_added_newline():
            if self.opts.keep_array_indentation and self.is_array(self.flags.mode) and len(self.whitespace_before_token) > 0:
                self.output.append(''.join(self.whitespace_before_token))
            else:
                if self.preindent_string:
                    self.output.append(self.preindent_string)

                self.append_indent_string(self.flags.indentation_level)
                self.append_indent_string(self.flags.var_line and self.flags.var_line_reindented)
                self.append_indent_string(self.output_wrapped)

    def append_indent_string(self, level = 1):
        if not isinstance(level, int):
            if level:
                level = 1
            else:
                level = 0

        if self.flags.last_text != '':
            for i in range(level):
                self.output.append(self.indent_string)

    def append_token_space_before(self):
        # make sure only single space gets drawn
        if self.output_space_before_token and len(self.output) and self.output[-1] not in [' ', '\n', self.indent_string]:
            self.output.append(' ')

    def append_token(self, s):
        self.append_token_line_indentation()
        self.output_wrapped = False
        self.append_token_space_before()
        self.output_space_before_token = False
        self.output.append(s)

    def indent(self):
        self.flags.indentation_level += 1

    def set_mode(self, mode):
        if self.flags:
            self.flag_store.append(self.flags)
            self.previous_flags = self.flags
        else:
            self.previous_flags = BeautifierFlags(mode)

        self.flags = BeautifierFlags(mode)
        self.flags.apply_base(self.previous_flags);

    def restore_mode(self):
        if len(self.flag_store) > 0:
            self.previous_flags = self.flags
            self.flags = self.flag_store.pop()

    def start_of_statement(self):
        if (self.flags.last_text == 'do' \
                or (self.flags.last_text == 'else' and self.token_text != 'if' ) \
                or (self.last_type == 'TK_END_EXPR' and (self.previous_flags.mode == MODE.ForInitializer or self.previous_flags.mode == MODE.Conditional))):
            self.allow_wrap_or_preserved_newline(self.token_text)
            self.set_mode(MODE.Statement)
            self.indent()
            self.output_wrapped = False
            return True
        else:
            return False

    def is_next(self, find):
        local_pos = self.parser_pos
        if local_pos >= len(self.input):
            return False
        c = self.input[local_pos]

        while (c in self.whitespace) and c != find:
            local_pos+= 1
            if local_pos >= len(self.input):
                return False
            c = self.input[local_pos]

        return c == find

    def get_next_token(self):

        self.n_newlines = 0

        if self.parser_pos >= len(self.input):
            return '', 'TK_EOF'

        self.input_wanted_newline = False
        self.whitespace_before_token = []

        c = self.input[self.parser_pos]
        self.parser_pos += 1

        while c in self.whitespace:
            if c == '\n':
                self.n_newlines += 1
                self.whitespace_before_token = []
            elif c == self.indent_string:
                self.whitespace_before_token.append(self.indent_string)
            elif c != '\r':
                self.whitespace_before_token.append(' ')

            if self.parser_pos >= len(self.input):
                return '', 'TK_EOF'

            c = self.input[self.parser_pos]
            self.parser_pos += 1

        if c in self.wordchar:
            if self.parser_pos < len(self.input):
                while self.input[self.parser_pos] in self.wordchar:
                    c = c + self.input[self.parser_pos]
                    self.parser_pos += 1
                    if self.parser_pos == len(self.input):
                        break

            # small and surprisingly unugly hack for IE-10 representation
            if self.parser_pos != len(self.input) and self.input[self.parser_pos] in '+-' \
               and re.match('^[0-9]+[Ee]$', c):

                sign = self.input[self.parser_pos]
                self.parser_pos += 1
                t = self.get_next_token()
                c += sign + t[0]
                return c, 'TK_WORD'

            if c == 'in': # in is an operator, need to hack
                return c, 'TK_OPERATOR'

            return c, 'TK_WORD'

        if c in '([':
            return c, 'TK_START_EXPR'

        if c in ')]':
            return c, 'TK_END_EXPR'

        if c == '{':
            return c, 'TK_START_BLOCK'

        if c == '}':
            return c, 'TK_END_BLOCK'

        if c == ';':
            return c, 'TK_SEMICOLON'

        if c == '/':
            comment = ''
            inline_comment = True
            if self.input[self.parser_pos] == '*': # peek /* .. */ comment
                self.parser_pos += 1
                if self.parser_pos < len(self.input):
                    while not (self.input[self.parser_pos] == '*' and \
                               self.parser_pos + 1 < len(self.input) and \
                               self.input[self.parser_pos + 1] == '/')\
                          and self.parser_pos < len(self.input):
                        c = self.input[self.parser_pos]
                        comment += c
                        if c in '\r\n':
                            inline_comment = False
                        self.parser_pos += 1
                        if self.parser_pos >= len(self.input):
                            break
                self.parser_pos += 2
                if inline_comment and self.n_newlines == 0:
                    return '/*' + comment + '*/', 'TK_INLINE_COMMENT'
                else:
                    return '/*' + comment + '*/', 'TK_BLOCK_COMMENT'

            if self.input[self.parser_pos] == '/': # peek // comment
                comment = c
                while self.input[self.parser_pos] not in '\r\n':
                    comment += self.input[self.parser_pos]
                    self.parser_pos += 1
                    if self.parser_pos >= len(self.input):
                        break

                return comment, 'TK_COMMENT'

        if c == "'" or c == '"' or \
            ( \
                (c == '/') or \
                (self.opts.e4x and c == "<" and re.match('^<[a-zA-Z:0-9]+\s*([a-zA-Z:0-9]+="[^"]*"\s*)*\/?\s*>', self.input[self.parser_pos - 1:])) \
            ) and ( \
                (self.last_type == 'TK_WORD' and self.is_special_word(self.flags.last_text)) or \
                (self.last_type == 'TK_END_EXPR' and self.previous_flags.mode in [MODE.Conditional, MODE.ForInitializer]) or \
                (self.last_type in ['TK_COMMENT', 'TK_START_EXPR', 'TK_START_BLOCK', 'TK_END_BLOCK', 'TK_OPERATOR', \
                                   'TK_EQUALS', 'TK_EOF', 'TK_SEMICOLON', 'TK_COMMA'])):
            sep = c
            esc = False
            esc1 = 0
            esc2 = 0
            resulting_string = c
            in_char_class = False

            if self.parser_pos < len(self.input):
                if sep == '/':
                    # handle regexp
                    in_char_class = False
                    while esc or in_char_class or self.input[self.parser_pos] != sep:
                        resulting_string += self.input[self.parser_pos]
                        if not esc:
                            esc = self.input[self.parser_pos] == '\\'
                            if self.input[self.parser_pos] == '[':
                                in_char_class = True
                            elif self.input[self.parser_pos] == ']':
                                in_char_class = False
                        else:
                            esc = False
                        self.parser_pos += 1
                        if self.parser_pos >= len(self.input):
                            # incomplete regex when end-of-file reached
                            # bail out with what has received so far
                            return resulting_string, 'TK_STRING'

                elif self.opts.e4x and sep == '<':
                    # handle e4x xml literals
                    xmlRegExp = re.compile('<(\/?)([a-zA-Z:0-9]+)\s*([a-zA-Z:0-9]+="[^"]*"\s*)*(\/?)\s*>')
                    xmlStr = self.input[self.parser_pos - 1:]
                    match = xmlRegExp.match(xmlStr)
                    if match:
                        rootTag = match.group(2)
                        depth = 0
                        while (match):
                            isEndTag = match.group(1)
                            tagName = match.group(2)
                            isSingletonTag = match.group(4)
                            if tagName == rootTag and not isSingletonTag:
                                if isEndTag:
                                    depth -= 1
                                else:
                                    depth += 1

                            if depth <= 0:
                                break

                            match = xmlRegExp.search(xmlStr, match.end())

                        if match:
                            xmlLength = match.end() # + len(match.group())
                        else:
                            xmlLength = len(xmlStr)

                        self.parser_pos += xmlLength - 1
                        return xmlStr[:xmlLength], 'TK_STRING'

                else:
                    # handle string
                    while esc or self.input[self.parser_pos] != sep:
                        resulting_string += self.input[self.parser_pos]
                        if esc1 and esc1 >= esc2:
                            try:
                                esc1 = int(resulting_string[-esc2:], 16)
                            except Exception:
                                esc1 = False
                            if esc1 and esc1 >= 0x20 and esc1 <= 0x7e:
                                esc1 = chr(esc1)
                                resulting_string = resulting_string[:-2 - esc2]
                                if esc1 == sep or esc1 == '\\':
                                        resulting_string += '\\'
                                resulting_string += esc1
                            esc1 = 0
                        if esc1:
                            esc1 += 1
                        elif not esc:
                            esc = self.input[self.parser_pos] == '\\'
                        else:
                            esc = False
                            if self.opts.unescape_strings:
                                if self.input[self.parser_pos] == 'x':
                                    esc1 += 1
                                    esc2 = 2
                                elif self.input[self.parser_pos] == 'u':
                                    esc1 += 1
                                    esc2 = 4
                        self.parser_pos += 1
                        if self.parser_pos >= len(self.input):
                            # incomplete string when end-of-file reached
                            # bail out with what has received so far
                            return resulting_string, 'TK_STRING'

            self.parser_pos += 1
            resulting_string += sep
            if sep == '/':
                # regexps may have modifiers /regexp/MOD, so fetch those too
                while self.parser_pos < len(self.input) and self.input[self.parser_pos] in self.wordchar:
                    resulting_string += self.input[self.parser_pos]
                    self.parser_pos += 1
            return resulting_string, 'TK_STRING'

        if c == '#':

            # she-bang
            if len(self.output) == 0 and len(self.input) > 1 and self.input[self.parser_pos] == '!':
                resulting_string = c
                while self.parser_pos < len(self.input) and c != '\n':
                    c = self.input[self.parser_pos]
                    resulting_string += c
                    self.parser_pos += 1
                return resulting_string.strip() + '\n', 'TK_UNKNOWN'

            # Spidermonkey-specific sharp variables for circular references
            # https://developer.mozilla.org/En/Sharp_variables_in_JavaScript
            # http://mxr.mozilla.org/mozilla-central/source/js/src/jsscan.cpp around line 1935
            sharp = '#'
            if self.parser_pos < len(self.input) and self.input[self.parser_pos] in self.digits:
                while True:
                    c = self.input[self.parser_pos]
                    sharp += c
                    self.parser_pos += 1
                    if self.parser_pos >= len(self.input)  or c == '#' or c == '=':
                        break
            if c == '#' or self.parser_pos >= len(self.input):
                pass
            elif self.input[self.parser_pos] == '[' and self.input[self.parser_pos + 1] == ']':
                sharp += '[]'
                self.parser_pos += 2
            elif self.input[self.parser_pos] == '{' and self.input[self.parser_pos + 1] == '}':
                sharp += '{}'
                self.parser_pos += 2
            return sharp, 'TK_WORD'

        if c == '<' and self.input[self.parser_pos - 1 : self.parser_pos + 3] == '<!--':
            self.parser_pos += 3
            c = '<!--'
            while self.parser_pos < len(self.input) and self.input[self.parser_pos] != '\n':
                c += self.input[self.parser_pos]
                self.parser_pos += 1
            self.flags.in_html_comment = True
            return c, 'TK_COMMENT'

        if c == '-' and self.flags.in_html_comment and self.input[self.parser_pos - 1 : self.parser_pos + 2] == '-->':
            self.flags.in_html_comment = False
            self.parser_pos += 2
            return '-->', 'TK_COMMENT'

        if c == '.':
            return c, 'TK_DOT'

        if c in self.punct:
            while self.parser_pos < len(self.input) and c + self.input[self.parser_pos] in self.punct:
                c += self.input[self.parser_pos]
                self.parser_pos += 1
                if self.parser_pos >= len(self.input):
                    break

            if c == ',':
                return c, 'TK_COMMA'
            if c == '=':
                return c, 'TK_EQUALS'

            return c, 'TK_OPERATOR'

        return c, 'TK_UNKNOWN'

    def handle_start_expr(self, token_text):
        if self.start_of_statement():
            # The conditional starts the statement if appropriate.
            pass

        if token_text == '[':
            if self.last_type == 'TK_WORD' or self.flags.last_text == ')':
                if self.flags.last_text in self.line_starters:
                    self.output_space_before_token = True
                self.set_mode(MODE.Expression)
                self.append_token(token_text)
                if self.opts.space_in_paren:
                    self.output_space_before_token = True
                return

            if self.is_array(self.flags.mode):
                if self.flags.last_text == '[' or (
                    self.flags.last_text == ',' and (self.last_last_text == ']' or self.last_last_text == '}')):
                    # ], [ goes to a new line
                    # }, [ goes to a new line
                    if not self.opts.keep_array_indentation:
                        self.append_newline()

        else:
            if self.flags.last_text == 'for':
                self.set_mode(MODE.ForInitializer)
            elif self.flags.last_text in ['if', 'while']:
                self.set_mode(MODE.Conditional)
            else:
                self.set_mode(MODE.Expression)

        if self.flags.last_text == ';' or self.last_type == 'TK_START_BLOCK':
            self.append_newline()
        elif self.last_type in ['TK_END_EXPR', 'TK_START_EXPR', 'TK_END_BLOCK'] or self.flags.last_text == '.':
            # do nothing on (( and )( and ][ and ]( and .(
            if self.input_wanted_newline:
                self.append_newline()
        elif self.last_type not in ['TK_WORD', 'TK_OPERATOR']:
            self.output_space_before_token = True
        elif self.flags.last_word == 'function' or self.flags.last_word == 'typeof':
            # function() vs function (), typeof() vs typeof ()
            if self.opts.jslint_happy:
                self.output_space_before_token = True
        elif self.flags.last_text in self.line_starters or self.flags.last_text == 'catch':
            # TODO: option space_before_conditional
            self.output_space_before_token = True

        # Support of this kind of newline preservation:
        # a = (b &&
        #     (c || d));
        if self.last_type in ['TK_EQUALS', 'TK_OPERATOR']:
            if self.flags.mode != 'OBJECT':
                self.allow_wrap_or_preserved_newline(token_text)

        self.append_token(token_text)
        if self.opts.space_in_paren:
            self.output_space_before_token = True
        if self.token_text == '[':
            self.set_mode(MODE.ArrayLiteral)
            self.indent()
        if self.dot_after_newline:
            self.dot_after_newline = False
            self.indent()

    def handle_end_expr(self, token_text):
        # statements inside expressions are not valid syntax, but...
        # statements must all be closed when their container closes
        while self.flags.mode == MODE.Statement:
            self.restore_mode()

        if self.token_text == ']' and self.is_array(self.flags.mode) and self.flags.multiline_array and not self.opts.keep_array_indentation:
            self.append_newline()

        self.restore_mode()
        if self.opts.space_in_paren:
            self.output_space_before_token = True
        self.append_token(token_text)

        # do {} while () // no statement required after
        if self.flags.do_while and self.previous_flags.mode == MODE.Conditional:
            self.previous_flags.mode = MODE.Expression
            self.flags.do_block = False
            self.flags.do_while = False

    def handle_start_block(self, token_text):
        self.set_mode(MODE.BlockStatement)

        empty_braces = self.is_next('}')
        empty_anonymous_function = empty_braces and self.flags.last_word == 'function' and \
            self.last_type == 'TK_END_EXPR'

        if self.opts.brace_style == 'expand':
            if self.last_type != 'TK_OPERATOR' and \
                (empty_anonymous_function or
                    self.last_type == 'TK_EQUALS' or
                    (self.is_special_word(self.flags.last_text) and self.flags.last_text != 'else')):
                self.output_space_before_token = True
            else:
                self.append_newline()
        else: # collapse
            if self.last_type not in ['TK_OPERATOR', 'TK_START_EXPR']:
                if self.last_type == 'TK_START_BLOCK':
                    self.append_newline()
                else:
                    self.output_space_before_token = True
            else:
                # if TK_OPERATOR or TK_START_EXPR
                if self.is_array(self.previous_flags.mode) and self.flags.last_text == ',':
                    if self.last_last_text == '}':
                        self.output_space_before_token = True
                    else:
                        self.append_newline()

        self.append_token(token_text)
        self.indent()

    def handle_end_block(self, token_text):
        # statements must all be closed when their container closes
        while self.flags.mode == MODE.Statement:
            self.restore_mode()

        self.restore_mode()

        empty_braces = self.last_type == 'TK_START_BLOCK';
        if self.opts.brace_style == 'expand':
            if not empty_braces:
                self.append_newline()
        else:
            # skip {}
            if not empty_braces:
                if self.is_array(self.flags.mode) and self.opts.keep_array_indentation:
                    self.opts.keep_array_indentation = False
                    self.append_newline()
                    self.opts.keep_array_indentation = True
                else:
                    self.append_newline()

        self.append_token(token_text)

    def handle_word(self, token_text):
        if self.start_of_statement():
            # The conditional starts the statement if appropriate.
            pass
        elif self.input_wanted_newline and \
                not self.is_expression(self.flags.mode) and \
                (self.last_type != 'TK_OPERATOR' or (self.flags.last_text == '--' or self.flags.last_text == '++')) and \
                self.last_type != 'TK_EQUALS' and \
                (self.opts.preserve_newlines or self.flags.last_text != 'var'):
            self.append_newline()

        if self.flags.do_block and not self.flags.do_while:
            if token_text == 'while':
                # do {} ## while ()
                self.output_space_before_token = True
                self.append_token(token_text)
                self.output_space_before_token = True
                self.flags.do_while = True
                return
            else:
                # do {} should always have while as the next word.
                # if we don't see the expected while, recover
                self.append_newline()
                self.flags.do_block = False

        if self.dot_after_newline and self.is_special_word(token_text):
            self.dot_after_newline = False

        # if may be followed by else, or not
        # Bare/inline ifs are tricky
        # Need to unwind the modes correctly: if (a) if (b) c(); else d(); else e();
        if self.flags.if_block:
            if token_text != 'else':
                while self.flags.mode == MODE.Statement:
                    self.restore_mode()

                self.flags.if_block = False;

        if token_text == 'function':
            if self.flags.var_line and self.flags.last_text != '=':
                self.flags.var_line_reindented = not self.opts.keep_function_indentation
            if (self.just_added_newline() or self.flags.last_text == ';' or self.flags.last_text == '}') and \
                    self.flags.last_text != '{' and not self.is_array(self.flags.mode):
                # make sure there is a nice clean space of at least one blank line
                # before a new function definition, except in arrays
                if not self.just_added_newline():
                    self.append_newline(True)
                if not self.just_added_blankline():
                    self.append_newline(True)

            if self.last_type == 'TK_WORD':
                if self.flags.last_text in ['get', 'set', 'new', 'return']:
                    self.output_space_before_token = True
                else:
                    self.append_newline()
            elif self.last_type == 'TK_OPERATOR' or self.flags.last_text == '=':
                # foo = function
                self.output_space_before_token = True
            elif self.is_expression(self.flags.mode):
                # (function
                pass
            else:
                self.append_newline()

            self.append_token(token_text)
            self.flags.last_word = token_text
            return

        if token_text == 'case' or (token_text == 'default' and self.flags.in_case_statement):
            self.append_newline()
            if self.flags.case_body or self.opts.jslint_happy:
                self.flags.case_body = False
                self.flags.indentation_level -= 1
            self.append_token(token_text)
            self.flags.in_case = True
            self.flags.in_case_statement = True
            return

        prefix = 'NONE'

        if self.last_type == 'TK_END_BLOCK':
            if token_text not in ['else', 'catch', 'finally']:
                prefix = 'NEWLINE'
            else:
                if self.opts.brace_style in ['expand', 'end-expand']:
                    prefix = 'NEWLINE'
                else:
                    prefix = 'SPACE'
                    self.output_space_before_token = True
        elif self.last_type == 'TK_SEMICOLON' and self.flags.mode == MODE.BlockStatement:
            # TODO: Should this be for STATEMENT as well?
            prefix = 'NEWLINE'
        elif self.last_type == 'TK_SEMICOLON' and self.is_expression(self.flags.mode):
            prefix = 'SPACE'
        elif self.last_type == 'TK_STRING':
            prefix = 'NEWLINE'
        elif self.last_type == 'TK_WORD':
            prefix = 'SPACE'
        elif self.last_type == 'TK_START_BLOCK':
            prefix = 'NEWLINE'
        elif self.last_type == 'TK_END_EXPR':
            self.output_space_before_token = True
            prefix = 'NEWLINE'

        if token_text in self.line_starters:
            if self.flags.last_text == 'else':
                prefix = 'SPACE'
            else:
                prefix = 'NEWLINE'

        if self.last_type in ['TK_COMMA', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']:
            if self.flags.mode != 'OBJECT':
                self.allow_wrap_or_preserved_newline(token_text)

        if token_text in ['else', 'catch', 'finally']:
            if self.last_type != 'TK_END_BLOCK' \
               or self.opts.brace_style == 'expand' \
               or self.opts.brace_style == 'end-expand':
                self.append_newline()
            else:
                self.trim_output(True)
                # If we trimmed and there's something other than a close block before us
                # put a newline back in.  Handles '} // comment' scenario.
                if self.output[-1] != '}':
                    self.append_newline()

                self.output_space_before_token = True

        elif prefix == 'NEWLINE':
            if self.is_special_word(self.flags.last_text):
                # no newline between return nnn
                self.output_space_before_token = True
            elif self.last_type != 'TK_END_EXPR':
                if (self.last_type != 'TK_START_EXPR' or token_text != 'var') and self.flags.last_text != ':':
                    # no need to force newline on VAR -
                    # for (var x = 0...
                    if token_text == 'if' and self.flags.last_word == 'else' and self.flags.last_text != '{':
                        self.output_space_before_token = True
                    else:
                        self.flags.var_line = False
                        self.flags.var_line_reindented = False
                        self.append_newline()
            elif token_text in self.line_starters and self.flags.last_text != ')':
                self.flags.var_line = False
                self.flags.var_line_reindented = False
                self.append_newline()
        elif self.is_array(self.flags.mode) and self.flags.last_text == ',' and self.last_last_text == '}':
            self.append_newline() # }, in lists get a newline
        elif prefix == 'SPACE':
            self.output_space_before_token = True

        self.append_token(token_text)
        self.flags.last_word = token_text

        if token_text == 'var':
            self.flags.var_line = True
            self.flags.var_line_reindented = False
            self.flags.var_line_tainted = False

        if token_text == 'do':
            self.flags.do_block = True

        if token_text == 'if':
            self.flags.if_block = True

    def handle_semicolon(self, token_text):
        while self.flags.mode == MODE.Statement and not self.flags.if_block:
            self.restore_mode()

        self.append_token(token_text)
        self.flags.var_line = False
        self.flags.var_line_reindented = False
        if self.flags.mode == 'OBJECT':
            # OBJECT mode is weird and doesn't get reset too well.
            self.flags.mode = MODE.BlockStatement

    def handle_string(self, token_text):
        if self.start_of_statement():
            # The conditional starts the statement if appropriate.
            # One difference - strings want at least a space before
            self.output_space_before_token = True
        elif self.last_type == 'TK_WORD':
            self.output_space_before_token = True
        elif self.last_type == 'TK_END_EXPR' and self.previous_flags.mode in [MODE.Conditional, MODE.ForInitializer]:
            self.output_space_before_token = True
        elif self.last_type in ['TK_COMMA', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']:
            if self.flags.mode != 'OBJECT':
                self.allow_wrap_or_preserved_newline(token_text)
        else:
            self.append_newline()

        self.append_token(token_text)

    def handle_equals(self, token_text):
        if self.flags.var_line:
            # just got an '=' in a var-line, different line breaking rules will apply
            self.flags.var_line_tainted = True

        self.output_space_before_token = True
        self.append_token(token_text)
        self.output_space_before_token = True

    def handle_comma(self, token_text):
        if self.flags.var_line:
            if self.is_expression(self.flags.mode) or self.last_type == 'TK_END_BLOCK':
                # do not break on comma, for ( var a = 1, b = 2
                self.flags.var_line_tainted = False

            if self.flags.var_line:
                self.flags.var_line_reindented = True

            self.append_token(token_text)

            if self.flags.var_line_tainted:
                self.flags.var_line_tainted = False
                self.append_newline()
            else:
                self.output_space_before_token = True

            return

        if self.last_type == 'TK_END_BLOCK' and self.flags.mode != MODE.Expression:
            self.append_token(token_text)
            if self.flags.mode == 'OBJECT' and self.flags.last_text == '}':
                self.append_newline()
            else:
                self.output_space_before_token = True
        else:
            if self.flags.mode == 'OBJECT':
                self.append_token(token_text)
                self.append_newline()
            else:
                # EXPR or DO_BLOCK
                self.append_token(token_text)
                self.output_space_before_token = True

    def handle_operator(self, token_text):
        space_before = True
        space_after = True

        if self.is_special_word(self.flags.last_text):
            # return had a special handling in TK_WORD
            self.output_space_before_token = True
            self.append_token(token_text)
            return

        # hack for actionscript's import .*;
        if token_text == '*' and self.last_type == 'TK_DOT' and not self.last_last_text.isdigit():
            self.append_token(token_text)
            return

        if token_text == ':' and self.flags.in_case:
            self.flags.case_body = True
            self.indent()
            self.append_token(token_text)
            self.append_newline()
            self.flags.in_case = False
            return

        if token_text == '::':
            # no spaces around the exotic namespacing syntax operator
            self.append_token(token_text)
            return

        # http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1
        # if there is a newline between -- or ++ and anything else we should preserve it.
        if self.input_wanted_newline and (token_text == '--' or token_text == '++'):
            self.append_newline()

        if token_text in ['--', '++', '!'] \
                or (token_text in ['+', '-'] \
                    and (self.last_type in ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR'] \
                    or self.flags.last_text in self.line_starters or self.flags.last_text == ',')):

            space_before = False
            space_after = False

            if self.flags.last_text == ';' and self.is_expression(self.flags.mode):
                # for (;; ++i)
                #         ^^
                space_before = True

            if self.last_type == 'TK_WORD' and self.flags.last_text in self.line_starters:
                space_before = True

            if self.flags.mode == MODE.BlockStatement and self.flags.last_text in ['{', ';']:
                # { foo: --i }
                # foo(): --bar
                self.append_newline()

        elif token_text == ':':
            if self.flags.ternary_depth == 0:
                if self.flags.mode == MODE.BlockStatement:
                    self.flags.mode = 'OBJECT'
                space_before = False
            else:
                self.flags.ternary_depth -= 1
        elif token_text == '?':
            self.flags.ternary_depth += 1

        if space_before:
            self.output_space_before_token = True

        self.append_token(token_text)

        if space_after:
            self.output_space_before_token = True

    def handle_block_comment(self, token_text):

        lines = token_text.replace('\x0d', '').split('\x0a')
        # all lines start with an asterisk? that's a proper box comment
        if not any(l for l in lines[1:] if ( l.strip() == '' or (l.lstrip())[0] != '*')):
            self.append_newline(preserve_statement_flags = True)
            self.append_token(lines[0])
            for line in lines[1:]:
                self.append_newline(preserve_statement_flags = True)
                self.append_token(' ' + line.strip())
        else:
            # simple block comment: leave intact
            if len(lines) > 1:
                # multiline comment starts on a new line
                self.append_newline(preserve_statement_flags = True)
            else:
                # single line /* ... */ comment stays on the same line
                self.output_space_before_token = True

            self.append_token(lines[0])
            self.output.append('\n')
            for line in lines[1:]:
                self.output.append(line)
                self.output.append('\n')

        if not self.is_next('\n'):
            self.append_newline(preserve_statement_flags = True)

    def handle_inline_comment(self, token_text):
        self.output_space_before_token = True
        self.append_token(token_text)
        self.output_space_before_token = True

    def handle_comment(self, token_text):
        if self.input_wanted_newline:
            self.append_newline(preserve_statement_flags = True)

        if not self.input_wanted_newline:
            self.trim_output(True)

        self.output_space_before_token = True
        self.append_token(token_text)
        self.append_newline(preserve_statement_flags = True)

    def handle_dot(self, token_text):
        if self.is_special_word(self.flags.last_text):
            self.output_space_before_token = True
        else:
            # allow preserved newlines before dots in general
            # force newlines on dots after close paren when break_chained - for bar().baz()
            self.allow_wrap_or_preserved_newline(token_text,
                self.flags.last_text == ')' and self.opts.break_chained_methods)

        if self.just_added_newline():
            self.dot_after_newline = True

        self.append_token(token_text)

    def handle_unknown(self, token_text):
        self.append_token(token_text)
        if token_text[len(token_text) - 1] == '\n':
            self.append_newline()

def main():

    argv = sys.argv[1:]

    try:
        opts, args = getopt.getopt(argv, "s:c:o:dPjbkil:xhtfvXw:",
            ['indent-size=','indent-char=','outfile=', 'disable-preserve-newlines',
            'space-in-paren', 'jslint-happy', 'brace-style=', 'keep-array-indentation',
            'indent-level=', 'unescape-strings', 'help', 'usage', 'stdin', 'eval-code',
            'indent-with-tabs', 'keep-function-indentation', 'version', 'e4x', 'wrap-line-length'])
    except getopt.GetoptError as ex:
        print(ex, file=sys.stderr)
        return usage(sys.stderr)

    js_options = default_options()

    file = None
    outfile = 'stdout'
    if len(args) == 1:
        file = args[0]

    for opt, arg in opts:
        if opt in ('--keep-array-indentation', '-k'):
            js_options.keep_array_indentation = True
        if opt in ('--keep-function-indentation','-f'):
            js_options.keep_function_indentation = True
        elif opt in ('--outfile', '-o'):
            outfile = arg
        elif opt in ('--indent-size', '-s'):
            js_options.indent_size = int(arg)
        elif opt in ('--indent-char', '-c'):
            js_options.indent_char = arg
        elif opt in ('--indent-with-tabs', '-t'):
            js_options.indent_with_tabs = True
        elif opt in ('--disable-preserve_newlines', '-d'):
            js_options.preserve_newlines = False
        elif opt in ('--space-in-paren', '-P'):
            js_options.space_in_paren = True
        elif opt in ('--jslint-happy', '-j'):
            js_options.jslint_happy = True
        elif opt in ('--eval-code'):
            js_options.eval_code = True
        elif opt in ('--brace-style', '-b'):
            js_options.brace_style = arg
        elif opt in ('--unescape-strings', '-x'):
            js_options.unescape_strings = True
        elif opt in ('--e4x', '-X'):
            js_options.e4x = True
        elif opt in ('--wrap-line-length ', '-w'):
            js_options.wrap_line_length = int(arg)
        elif opt in ('--stdin', '-i'):
            file = '-'
        elif opt in ('--version', '-v'):
            return print(__version__)
        elif opt in ('--help', '--usage', '-h'):
            return usage()

    if not file:
        print("Must define at least one file.", file=sys.stderr)
        return usage(sys.stderr)
    else:
        try:
            if outfile == 'stdout':
                print(beautify_file(file, js_options))
            else:
                with open(outfile, 'w') as f:
                    f.write(beautify_file(file, js_options) + '\n')
        except Exception as ex:
            print(ex, file=sys.stderr)
            return 1

    # Success
    return 0

redpajama_set_name: RedPajamaGithub


One of the common topics that comes up for people is how to bring spirituality into difficult situations. A lot of people who are doing spiritual work find that life still has lots of hard moments. And that won't change. Being awakened won't make life easier, per se. It makes it easier in the sense that we're not resisting what's happening in our lives or making up as many stories about what has happened. But being awakened doesn't change the feeling of being hungry when there's no food. It doesn't stop your boss who has control issues from abusing yourself and other colleagues. It doesn't turn life into a rainbow filled, fluffy bunny prince and princess world. If you want that, go to an amusement park--but then again, you'll be "paying" for that experience as well.
I decided to put "limited" in this subhead because I think there's just something so ingrained in us about resisting the present moment when it isn't to our preferences. Preferences, by the way, don't necessarily go away when you wake up. Instead, they become more optional. I prefer to not be yelled at by colleagues and other people. If it happens, it's not as activating as before. I understand that 90% of the time those situations aren't about me. I understand this from a very deep and powerful place within me. However, I still don't particularly want that experience in my life.
So you may have some part of you that still tries to resist as you do your work, and wherever that resistance is, you have something to work on releasing. But you're not trying to be perfect. You're not trying to get out of life without any kind of difficulty. The more deeply you embody awakening, the less you describe life in terms of difficult or easy, good or bad. It is simply life, and whatever is happening--including your three year old screaming at the top of her lungs at 4am--is simply life...neither good or bad. So how do you bring more awareness to yourself to let go of resistance at 4 in the morning?
I think that for the last couple months I've been beating the drum for discipline. Spiritual discipline helps us to make space for ourselves--our true selves. Without that space, things can get real messy, real fast. Thing get messy even when we have that discipline. I was hardly without tools when I had my awakening several years ago, but it took quite a few years to really figure out how to let go and re-engage with life from a totally different way of being. A lot of people want to run right into awakening, and I have people asking me about how to wake up their Kundalini. I patiently explain that most people don't really want this, and they're not ready for this yet. It's like turning on 400 volts of electricity when you haven't set up all your wiring yet. You're going to get fried.
Subsequently, building a practice and focusing on how you bring awareness to difficult situations goes a looooonnnnng way towards clearing out issues in your life that would immediately get activated with awakening or even with an iddy biddy opening into your deeper self. Everything gets lit up in awakening. So if you have big power issues and have attracted a controlling boss to show you how you give up your power in life, in awakening, you'd be even more freaked out about your difficult work situation. It can be unbearable all at once, and everything else that you haven't worked through gets lit up as well. It incapacitates some people.
I think that for many of you working on the spiritual path, you think that everyone will now love you because you're doing this stuff. It's another ego game to somehow manifest the perfect world in our lives. That won't happen. Certainly, people will flow in and out of your life, and right now, I am attracting many amazing and wonderful people that is absolutely awe-inspiring and humbling. The more you act from that deep space of integrity and love, the more you can attract others of the same energy vibration. I wouldn't quite call it law of attraction, but some of that applies (Ultimately, I don't believe everything that comes into our life is because we specifically attracted it into our lives. I also believe that people get into not-so-subtle levels of manipulation by trying to attract "good" stuff and avoiding "bad" stuff. Life is far more vast than any philosophy).
Yet, many people who stay in your life won't change. They still won't get you, and some will want to take out their frustrations with themselves on you. This is when the immature ego in you that's still holding on starts wailing like the 3 year old at 4 AM, "Why doesn't everyone love me?" Sorry. They've got their own stuff to deal with. Instead, pay attention to why you're having this reaction. Very simply in this scenario, we can see an underlying approval issue. Looking for approval from others is usually a shell issue for needing to approve of and love ourselves.
Since difficult situations won't go away, I encourage you to use them. When I first suggest this to students and others who connect with me, I'm sure the initial response in their minds is something like, "But I can't do that." Yes, you can, and you're the only one who can do that for you. You need to deal with any avoidance tendencies that you have to stand in that frying pan. Now, the point is not to go looking for difficult situations to prove yourself either, but if you've got lemons, you might as well make lemonade. Having a meditation practice and other practices helps you to become aware of yourself and how to be fully present in these difficult moments so that you fully learn what ever lesson is in them for you.
Building up your awareness and general calmness helps you to take a deeper level of presence out into the world when the situations aren't so serene and peaceful. This, of course, is where deeper awareness is most needed. We can't hide this stuff in monasteries and Sunday meditation groups. We need it in the world...desperately. So if you've got a little bit of an altruistic spirit, think of being in difficult situations mindfully as being one way that you're changing the world. I won't say to enjoy the heat, but pay attention to it. See what is there for you that is making it so "hot."
There have been enough martyrs in the name of religion or spirituality, so I don't want you to think that you're just supposed to hurl yourself into the teeth of vicious gossip circles, companies, relationships, and whatnot. This isn't a take-one-for-the-team situation. This is about learning what you need to learn from difficult situations and making the changes that you need within yourself. In some scenarios, you will quit your job, or you will take your power back by sending in your resignation to your boss. In others, it'll mean speaking your voice to your boss (or whoever the abuser is), or perhaps in another, it'll be a mindful, well-documented report to HR about your boss. There are many, many avenues, and there are many, many ways that things can work out.
But most importantly, don't react initially. When things are getting hot, give yourself the extra moment and extra breath to gather yourself. Allow yourself to assess the situation, and then trust your actions. Later on, it's time to journal and delve even more deeply into how you responded and what happened. You may even bring in a trusted friend or co-worker for an outside perspective. And don't expect a perfect solution. There may not be one. As I said, the spiritual path doesn't necessarily make things easier. It is the path through pain and difficulty, not away from it. But I assure you that the more mindfulness and awareness you bring to any difficult situation, the better the chance that something positive results as opposed to going through another cycle of pain and dis-ease.
This is a great post. I was nodding my head in agreement all the way through! I know from my own practice that when some challenging things happened earlier this year, my "habits" kicked in and I got through the difficulties so much better. In fact, the challenging events became my practice in a way, and my faith was deepened over the year. And the difficulties became blessings.
Thank you for sharing, Galen. It's so wonderful to hear others talk about how deepening their spiritual practices has helped them to transmute difficulty into blessing. Awesome.
Thank you for the reminders...my faith too has deepened as a result of "difficult" transitions.
You're welcome, Laura. Thanks for sharing.
Hi Jim, thanks for sending me this link. The article comes at hand for the many situations in life.
Resistance seems to be the key word. I realised that some time ago.
I don't offer much resistance to nature's surprises of bad weather or worse. But when somebody else might have been involved, not doing what is expected, the resistance grows.
I think that by adjusting 'expectations' a lot of resistance can be avoided.
Resistance against the forces of nature seems pointless, but so is resistance against babies crying, or children making noisy plays outside. What about resistance against suicide interupting traffic? What about resistance against vandalism? What about resistance against a strike happening unexpectedly. What about resistance when somebody cuts you of on the road. Or when someone is threatening your physical integrity? Can we still adjust our expectations. Can we leave them behind alltogether, and live in reality as it unfolds?
There's a difference between resisting a situation and being run-over by whatever happens in it. Accepting that people are vandalizing something is being in non-resistance. That doesn't mean that you don't call the police or say something to the people doing the vandalism. Part of awakened action is doing what you feel true to do in that moment. Usually, people resist what they know they need to do internally and get caught up in mental games. That makes difficult situations unbearable.


text:
Rocco Siffredi, Godfather of Rough Sex: 'What You Call Violence, I Call Pain with Pleasure'
ROCCO'S MODERN LIFE
The porn legend—and subject of the documentary 'Rocco'—sits down with Marlow Stern to discuss his long, dark journey to retirement, overcoming sex addiction, and more.
Marlow Stern
Senior Entertainment Editor
Updated Jul. 12, 2017 8:26PM ET / Published Oct. 22, 2016 8:37AM ET
©EMMANUEL GUIONET / Wild Bunch
When Rocco Antonio Tano was 9, his mother caught him masturbating.
The incident occurred on the balcony of his family's home in Ortona, a quaint coastal town in Italy that once played host to the Battle of Ortona, otherwise known as "Italian Stalingrad"—a gruesome 8-day confrontation between two battalions of German Fallschirmjäger and a brigade from the Canadian 1st Infantry Division during World War II. An overwhelming sense of shame washed over him. His mother was the light of his life, and, as with most Italian ragazzi, her approval meant everything to him. So young Rocco spent the next two hours locked in the bathroom, divorced from reality.
Then came the all too familiar scream: The pasta is cold! The pasta is cold! Head held low, he dragged his miniature body over to the dinner table. When Rocco mustered the courage to look up, he locked eyes with his mother. And much to his surprise, she was smiling. "Don't worry," she said, "you just became an adult."
That scared little boy grew up to be Rocco Siffredi, aka "The Italian Stallion"—a porn icon who has starred in roughly 1,400 films. Named after Alain Delon's gangster character Roch Siffredi in the 1970 French film Borsalino, Rocco is renowned for his movie star looks and particularly rough brand of onscreen sex, as well as his majestic cock. If there were a Mount Rushmore of porn penises, his 24 cm fuck stick would assume its rightful place alongside those of John Holmes, Ron Jeremy, and Lexington Steele.
"Can I tell you something?" Rocco asks me. "Did you see the movie Shame?"
We're seated across from one another at a pop-up café on the Lido, an island in Venice, Italy, about 550 km north of Ortona. The occasion, aside from our stunning view of the Adriatic Sea, is the Venice Film Festival where Rocco, a stylish documentary on the sex god helmed by French duo Thierry Demaiziere and Alban Teurlai, made its world premiere. The film chronicles his tumultuous 2015, the final year of the now-retired Rocco's porn career, as he travels between his home in Budapest—where he lives with his wife and two sons, and operates a porn studio—to shoots in Los Angeles and elsewhere. It also dedicates much of its 105-minute running time to Rocco's battle with the "devil between his legs."
Which brings us to Shame, the powerful Steve McQueen film featuring Michael Fassbender as a sex addict battling his demons in Manhattan. "When I saw this movie," says Rocco in his thick Italian accent, "it gave me nightmares. Night after night. Fassbender in that movie went through exactly what I went through. All of it."
It began in 2004 when Rocco decided to quit porn. He'd just turned 40, and his eldest son was starting to reach the age where children wonder what daddy does for a living: "When I decided to do porn, I said, 'No family.' Then I decided to start a family, then the boys came. And they grew. I didn't want them to see, so I thought it was better to stop before they grew too much."
"One day I'm playing with my son," he continues, "and then my body changed. I felt I needed to go."
So Rocco left. He would disappear for days at a time, scouring the internet for sex. "I started to see hookers every day," he recalls. "Also transsexuals, old women, any kind of thing. I didn't figure out that I was addicted to sex."
His lowest point, he says, mirrored a sequence in Shame where Michael Fassbender's character, after being spurned by a woman and assaulted by her boyfriend, enters a gay sex club where he begrudgingly receives oral sex from a male stranger. A similar scene occurred between Rocco and a random man at a sauna in France.
"There was the point. I went to this, with a guy," says Rocco. "You see in Shame that he went with a guy not because he's a homosexual, but because his brain is so fucked up that he needs to do anything to get pleasure, to get sweet release."
Rocco has always loved sex. He chuckles at the memory of losing his virginity as a 13-year-old to a 21-year-old woman with "the biggest bush ever" (it was the '70s, after all). By the time he was 20, he'd started frequenting a sex club in Paris. He became known throughout the club as "the Italian guy with the big dick." One evening, while he was having sex with a woman, he spotted his porn idol, Gabriel Pontello, looking on—holding a cigar in one hand and his dick in the other. Pontello introduced the 20-year-old to porn producers, and the rest is history.
To say that Rocco engages in "rough" sex is a vast understatement. Spitting, slapping, and choking are hallmarks of a Rocco film. It is animalistic. His most notorious scene involves him taking a woman from behind while flushing her head in a toilet. But Rocco didn't always like it rough. His taste for the extreme began when he was 22, at the hands of a British porn star named Tina.
"I didn't know what any of it meant," he remembers. "I was fucking her and all of a sudden she slapped my face so hard. She couldn't come. So instinctively I slapped her back—and she immediately came. For six months, we fucked only like this. And it went further, and further, and further. I learned that some women need more attention. What you call violence, I call pain with pleasure. They go together. Men understand this far less than women. I become exactly what they want. I love to give. I am very generous. I can only come if I see them coming."
Because of his rough style, Rocco has developed a reputation for "breaking" women—that is, pushing them to their absolute sexual limit. In Rocco, porn producers warn their clients beforehand that the sex will be strenuous, and usually give the women a day or two off after to recuperate.
"I had this reputation that was bad," says Rocco. "Girls didn't want to work with me because they saw how it was in the movies and they would pre-judge. They'd say, 'No, I don't want to work with this guy. He's too rough.' And they'd come to me after when they don't have so much work and say, 'Now we can work together.' And after we work together, they say, 'Oh, I don't understand why they say this about you. You are such a nice guy.'" "I had people using this part"—he points to his penis—"to put me down. I have a big dick. I am European John Holmes. It got jealous so many people in this business. So they thought, 'How can we fuck him up? His sexuality.'"
Indeed, Rocco comes off as a very attentive scene partner in the documentary; a man sensitive to the needs of his onscreen women. He claims that consent is of the utmost importance to him, and is adamant that he has never had—unlike the man who idolizes him, James Deen—a co-star accuse him of sexual assault.
"Never. Ever. The reputation is they know. When they arrive, I tell them, 'I have an amplifier on me. You decide the volume. Just let me know how high or low to turn it,'" he says. "Some girls come to me and say, 'Rocco, I don't like your style of sex with the slapping.' And I say, 'OK, what kind of sex do you like?' And I do that. I can adjust. Girls in America come to me and say, 'Rocco, I have no limits. Try to find my limit.' And then after they say, 'Wow, Rocco, you fucked me so hard.' And I say, 'Well, you asked me to.' So it depends how much you want to challenge me."
Many people consider your style of sex violent and borderline misogynistic, I tell him.
"Visually, it is violent. When you don't understand this kind of sexuality you only see violence," he explains. "But if you understand this sexuality, there is no violence. It's an interchange of pleasure, pain, and pressure. I don't like to fuck girls only with my dick; I use all the senses. I love to use my sense of smell, saliva—to melt with the person."
"But none of it is about hating women, or who is more strong," he adds. "Thirty-two years I do this business. If I hated women, I'd be in a mental hospital."
Following a five-year hiatus, where Rocco descended into sex addiction and nearly ruined his marriage, he rejoined the porn ranks in 2009. He retired again from performing in 2015 (though still directs and produces) after appearing on L'Isola dei Famosi, an Italian reality show where he was tasked with being stranded naked and alone on a beach for a week.
"I had an experience on the island where you're completely alone. Completely alone. No more business, no more family. It's just you," he recalls. "And it was the analysis that I never really went through. I discovered what my real priorities were—that everything else, all the women, it was all fake. The power and the beauty was not real. And it's not important to me anymore."
In addition to porn, Rocco has appeared in a number of acting roles in feature films, including Catherine Breillat's French dramas Romance and Anatomy of Hell, as well as the Italian comedy Wedding in Paris. These days, he's acting as a sex ambassador of sorts. Late last year, he launched an online petition addressed to Italian education minister Stefania Giannini calling for mandatory sex education in Italian schools, since most Italian schools do not teach sex ed.
"I'm going to disco most of the time to do special appearance, and lots of teenagers—14, 15 years old—they are asking me for autographs," says Rocco. "The boyfriend and girlfriend will come, and girlfriend will say, 'Rocco, can you tell him I don't like the way he fucks me? He is very rough. He slaps me, he chokes me, and he is your biggest fan. He says he wants to fuck me like Rocco.'" "I'm like, 'Jesus, this is not very good. Guys: porn is not sex education. It is entertainment for adults. It is fantasy.' But teenagers don't understand this. And Italy is the worst because their parents think their teenage sons don't watch porn. My balls."
The worst part, he says, is the barrage of onscreen imitators he's inspired—from accused serial rapist James Deen to a host of others; men who like to be rough with women on camera without forging the proper connection.
"When I hire a new guy, they immediately start up with this"—he mimics a man slapping a woman—"in the first ten seconds. And I'm like, 'What the fuck are you doing?' The guy goes, 'Hey, Roc! I thought you liked this? It's your style!' And I'm like, 'Is that what you learned?'" He shakes his head. "There is a moment of approval; a moment of connection. First you connect with the girl, you start fucking each other, and there is a moment of connection. And then you can try to push things further with each other."

redpajama_set_name: RedPajamaCommonCrawl


text:
What to see and what to skip in Oakland
Oakland is giving its famous neighbor across San Francisco Bay competition.
By GABE SAGLIE
Oakland, California, file photo
— -- Word's out: Oakland, California, is giving its famous neighbor across San Francisco Bay a run for its money.
Thanks to a slew of new businesses and attractions, the thriving city is seeing a tourism renaissance. Visitor numbers to Oakland have surged 27 percent in just the last four years; more than 3.7 million travelers arrived here in 2016.
The vibe here is urban, artsy and modern all at once, and the city's cultural and historical highlights make it an especially unique destination.
Here are some of the special things to see and do in Oakland.
What to see and what to skip in Edinburgh
What to see and what to skip on Florida's Space Coast
Skip SFO, fly into OAK
If you're headed to East Bay destinations, like Oakland, flying into Oakland International Airport can be a no-brainer. OAK doesn't have as many nonstop options as the much larger and busier SFO, across the Bay. Various low-frills carriers, though, service OAK, making fares competitive, and experiences like renting a car and going through security can be a whole lot easier. OAK is less than 10 miles, or a 15-minute drive, from downtown Oakland.
Skip the walking tour, take off
Want a bird's-eye view of famous San Francisco Bay? Take off with San Francisco Air Tours, which operates Cessna 207s out of OAK and takes guests soaring over Oakland, San Francisco and Sausalito and landmarks like the Golden Gate Bridge, Alcatraz and Pier 39. Flights are perfect for families, since they accommodate up to six people, and snacks like popcorn and cookies come standard. Every seat is a window seat and pilots are fluent in English, Spanish and German. The popular Golden Tour lasts about an hour total, with at least 30 minutes of air time.
Skip the hotel, snooze at the zoo
The Oakland Zoo offers some awesome sights, too: the Landing Café offers panoramic views of the Bay Area and a new gondola whisks guests high above the still-expanding California Trail. This popular animal haven also offers the unique chance to spend the night among your favorite wild animals. The Family Sundown Safari is offered throughout the year, running from 5 p.m. to 10 a.m. the next day. Families bring their own tent and sleeping bags and, after setting up camp, enjoy an all-you-can-eat dinner, a twilight behind-the-scenes tour of the Children's Zoo, make snacks for animals, catch a show and enjoy smores by the campfire. The morning after includes breakfast and animal encounters. Come 10 a.m., guests can stick around and enjoy the zoo the rest of the day; more than 700 exotic and native animals live here.
Skip room service, nosh in town
The Claremont Hotel & Spa, A Fairmont Hotel, is easily one of area's the top places to stay. It features a prime and super unique East Bay location: the property's front door is in Oakland and the back door is in Berkeley. And dining at the onsite Limewood Bar & Restaurant (with Happy Hour $1.50 oysters and half-off martinis every weekday) is top notch. Some the best food discoveries, though, are in the city.
"No trip to Oakland is complete without good food and drink!" says the hotel's Chef Concierge, Jennifer Circelli, who's in the business if pointing discerning guests toward the best spots in town to nosh. "Try Flora, Plum, The Wolf and A16," she suggests. "But the list goes on and new restaurants and star chefs are constantly popping up thanks to skyrocketing costs across the Bay in San Francisco."
Can't settle on just one restaurant? "The Hive, an industrial space transformed into a hub for restaurants, artists and merchants, is home to Calavera, Drake's Brewery, Humphry Slocombe Ice Cream and more," says Circelli. "You'll also get a good feel for the diverse and engaged community that makes up Oakland here." Circelli also recommends locally-owned Local Food Adventures, which offers walking food tours of the Grand Lake and Rockridge neighborhoods.
Skip the bar, sip the beer
Thirsty? Oakland is now home to a dozen breweries, nine of which have taprooms open to the public along the Oakland Ale Trail. Circelli likes Diving Dog, Temescal Brewing and Pacific Coast Brewing Company. But visit them all and earn a free branded growler! There are several guided tour options, including Velocipede Tours, which peddles brew fans around in a custom 14-person bike. Look for four more brewery tasting rooms to open by the end of the year.
Skip the beer, taste the wine
In just the last couple of years, I've seen several wineries pop up in Oakland, mainly inside repurposed warehouse buildings. Ten wineries currently make up the Oakland Urban Wine Trail, most of them conveniently located near Jack London Square and the city's Amtrak station. These up and coming labels, like Brooklyn West, Jeff Cohn Cellars and Urban Legend, source grapes from all over California and are open to the public mostly on weekends.
Skip the gym, take a hike
There are hundreds of hiking trails in the East Bay. The Claremont's Circelli recommends the Claremont Canyon Regional Preserve, just behind the resort. "It's a fairly short, albeit steep hike, but the views from the top are incredible," she says. "You can see all of Berkeley, Oakland, and across the Bay into San Francisco. Spot the Golden Gate Bridge on clear days!"
Skip the shore, visit the lake
"I seriously love living in Oakland," says Jessica McNally, a producer in Travelzoo's San Francisco offices. Her favorite weekend escape is Lake Merritt, a heart-shaped lagoon with 3.4 miles of shoreline and plenty to do. "Grab a drink on the dock at Lake Chalet, catch impromptu salsa dancing or capoeira dancers at the pergola, stop in at the botanical gardens, or take the kids to Children's Fairyland," says McNally. "It's a great place to get a feel for the Oakland community." Circelli suggests a gondola ride on the waters of Lake Merritt, and a visit to its Grand Lake Farmers' Market. "Buy some fresh California produce, cheese and baked goods, and grab a spot on the grass on a sunny Sunday afternoon," she says.
After the museum, do the murmur
The spotlight is squarely on the Golden State at the Oakland Museum of California, near Lake Merritt, which is dedicated to the state's art, history and natural sciences. McNally likes visiting on Fridays, when the museum features food trucks, live music, dancing, an artisan marketplace, hands-on workshops and after-hours gallery access. "It's a great options for families, couples and everyone in between!" she says. Adult admission is half off and kids 18 and under get in for free. The every-Friday event runs 5-10 p.m.
"Oakland also has great museums and attractions for younger visitors," adds the Claremont's Circelli. "Kids can look through the largest research-quality telescopes open to the public west of the Mississippi at Chabot Space & Science Center or play pretend in the whimsical storybook sets at Children's Fairyland."
For more cultural immersion, join the Oakland Art Murmur (OAM) the first Friday of each month, held rain or shine. More than 50 art galleries and mixed-use venues throughout the city open to the public and feature free guided tours and exclusive events. OAM features a street festival Uptown, along Telegraph Avenue between Grand and 27th Street.
Reconnect with Jack London Square
What's probably Oakland's most popular entertainment destination "is in the midst of a revitalization," says McNally. Jack London Square "is a great spot to watch boats sail by, wander the Sunday farmer's market or eat dinner al fresco at a number of tasty restaurants, from wood-fired pizzas, to Latin-inspired tapas." Set along the scenic Oakland/Alameda Estuary, this vibrant waterfront spot also features kayak rentals and sailing charters. The USS Potomac, FDR's presidential yacht, offers dockside tours year-round and two-hour narrated history cruises from March through November.
Skip the megaplex, visit Grand Lake Theater
The historic Grand Lake Theater dates back to 1926, when it opened as a vaudeville show and silent movie house. You can see first-run films here, but the real draw are intimate auditoriums with their lavish décor, including Egyptian and Moorish motifs. All shows before 5:45 p.m. are $6, even 3-D screenings, and Wednesday is free popcorn day. Pop into the main auditorium on Friday and Saturday nights to see pre-movie performances on the theater's Mighty Wurlitzer Organ.
Snap a selfie at the wall
As part of an ongoing push to encourage custom mural projects throughout the city, Visit Oakland debuted an official visitor "selfie wall" in 2016. The colorful mural features myriad Oakland landmarks and attractions, like Lake Merritt, Children's Fairyland and the Oakland Urban Wine Trail. Visit the wall in front of the Oakland Marriott City Center and post your selfies with the hashtag #oaklandloveit.
Skip Uber, ride for free
Catch free rides around Oakland aboard the Broadway Shuttle, known to the locals as the "Free B." Sponsored by the City of Oakland, these green buses run along Broadway from Jack London to 27th Street and provide free hop-on, hop-off connections from BART, the San Francisco Bay Ferry and Amtrak stations to downtown restaurants and shops. Look for the signs with the green "B on Broadway" logo.
Gabe Saglie is Senior Editor for Travelzoo, which features exclusive deals in Oakland at www.travelzoo.com. Got your own favorite Oakland experience? Let him know on Twitter or Instagram: @gabesaglie.


A healthy body and beautiful is everyone's dream. Neither men nor women want definitely have the ideal body. To get the ideal body, there is no way a good diet and safe. Almost everyone agreed that the appearance is one of the important factors that support our performance at work and daily activity.
Often to get a healthy body and the ideal, one focuses only on the final result and did not pay much attention to the process. The body is overweight or obese, of course, does not happen in an instant.
To lose excess weight must pass through some period of time, ie in a few months or a few years so when we want to restore it to its original ideal conditions or conditions, of course, required a certain amount of time anyway.
The process of the instant diet is usually taken in a manner which is not a good diet, and too risky to our health in the short term and long term. In addition, the often forgotten by us are on a diet can not be done partially. How good diet is a healthy lifestyle series consisting of diet, regular exercise, and regular health check.
Therefore, for the sake of our health and the achievement of getting into shape, beautiful, as well as the avoidance of spend in huge costs, here are some ways a good diet.
One of the toughest challenges in the diet in Indonesia is how we can reduce eating rice. Many people do not realize that they are on a diet, but their bodies remain obese. This is due to the composition of the rice is still dominant in their daily menu.
In order to form a healthy body by doing this type of diet, must be complex carbs, such as brown rice or brown rice. In addition to rice, complex carbohydrates can be found in grains, wheat, beans, and vegetables.
Start your breakfast by eating complex carbohydrates such as brown rice. Complex carbohydrates are stored in the hull sections tend to be longer so that makes us powered all day, your blood sugar more stable, and we are not easily limp.
In connection with the intake of carbohydrates, the one thing we need to consider is to adjust your carbohydrate needs with our activities.
We need carbohydrates in many conditions move and strenuous activities, but if we are sedentary and rarely moving, it is good we replaced carbohydrates with foods that contain protein.
Running how proper diet can not be separated from the need to consume a lot of fruits and vegetables. There is a habit that one of the people of Indonesia, namely fruit eaten after eating the main menu.
The right thing is the fruit should be eaten before we take the main menu. By eating the fruit before eating will make the stomach to be filled in half. In addition, fruit accelerate metabolism function of the body, rich in fiber so that it has the ability to block fat.
In addition to fruit, you also have to consider the composition of vegetables in your daily menu. Always there are vegetables in each of your main meals.
Consuming fruits and vegetables is a must especially for people who are aged over 20 years. Getting older, your metabolism slows down so that more fruits and vegetables is absolutely required by the body.
Many people mistook the diet and tend to torture themselves. Diet is considered only eat once a day and do not eat anything other than the daily menu, and so avoid snacks.
In fact, the essence is to eat a regular diet with the appropriate portion and still enjoy a snack. The principle is to eat little but often. It also reduces carbohydrates and fats, and enjoy healthy snacks, such as fruits.
Changing the intensity of eating drastically, in addition prone to feelings of anxiety and stress, it is also harmful to the body. Dine in some people, in addition to the need also provide psychological gratification or bring a feeling of calm and comfortable.
The body is suddenly not getting the intake as usual, at the time-the next time it will ask for additional intake as compensation.
Adjusting the intensity of a regular meal is not a meal with the changes that must be done drastically, but the habit is formed gradually over time. This habit can be initiated and formed by scheduling daily menu.
How to correct diet always include a recommendation to exercise regularly. Logically, the food we eat is the fuel that needs to be burned into energy. If not burned, the excess energy will be stored as fat in the body.
Sport is often a bugbear for many people, especially for those who have high activity. Most reasoned do not have the time. Indeed it can be tricked, because of course there is a holiday that can be used for the exercise.
In addition, there will never be a time when we do not make time. One hour a day of 24 hours, of course it is very possible for us to schedule exercise into our daily agenda.
The next major issue is that often people are reluctant or lazy to exercise because it confused with the type of exercise that is suitable for them.
For those who like exercising alone or need a coach who can motivate, the current fitness and aerobics with low cost scattered everywhere.
For those of you who like to do sports activities in groups, cycling community can be an option. You can also easily sport most festive, such as walking or jogging around the residence.
You can also start with an easy thing, for example, prefer to go up and down stairs than the elevator, choose to walk for a short distance, and others.
The intensity of exercise is also important to note. Sports that do less than one hour less beneficial for weight reduction, because in the first 20 minutes, your body will process food stored in the hull as energy.
Only after that, the body will draw energy from the stored fat reserves in some parts of our body. Therefore, we should work out on an empty stomach.
The best time to exercise is in the morning. Key importance of exercising is that you have to please these activities and do not feel compelled to do so. Select the appropriate sport with pleasure and the ability of your body.
Humans can not change habits overnight, but nothing is impossible in this world if we want to try. Running diet right one requires us to no longer eat after 6 pm.
In fact many Indonesian people accustomed to dinner over at 6 pm. Yet according to the biological sciences, the stomach takes 3-5 hours to digest the food.
Imagine if we eat over at 6 pm, and after a rest or inactivity. Then the food we eat automatically stored in the fatty tissues of our body. That is, it takes extra hard exercise to burn the fat.
For those of you who have a habit of staying up, then it must be reduced. People who have a habit of staying up, tend to eat at night or midnight.
The logic is simple, to maintain ideal body weight, the amount of food intake must equal the amount of energy that comes out. If lack of intake, the body will lack the nutrients. Meanwhile, if the excess, the body will be obese or overweight.
If you care more correct way to diet that has been discussed, then the point is how do we change behavior and diet so that we can get a healthy body ideal.
Such measures do not require a lot of costs, but provide great benefits to our body and can last much longer so we will not be exposed to 'yo-yo syndrome'.
Yoyo syndrome is a situation where people who diet do not execute it with discipline so that the weight up and down with ease. Often getting up, instead of getting down.
The primary key is the right way to diet determination, motivation constantly, and discipline. This strong determination instilled in by pasting pictures of us as ideal stature and proportionate in the room.
Then, the motivation is continuous with the support of family, significant others, and giving gifts and sanctions on yourself for every 1 kg of body weight lost.
One important thing to remember, the main purpose of a good diet is a healthy body. While obtaining a proportionate body and confident in appearance is a bonus.
So, do a good diet and correct so that you will feel the captivating view. You would be more healthy and confident.


text:
Respiratory Therapy Faculty
naprush@umich.edu
Public Health and Health Sciences
Nicholas Prush, MHA, RRT-ACCS
Program Director, Respiratory Therapy Program
Education: MHA, RRT, RRT-ACCS
Nicholas Prush MHA, RRT-ACCS is the founding Program Director and Clinical Assistant Professor for the University of Michigan-Flint Bachelor of Science in Respiratory Therapy (BSRT) degree advancement program. Nicholas received his respiratory therapy training from Henry Ford Community College where he graduated with an AAS in 2003. He obtained his Bachelor of Applied Science (BAS) from Siena Heights University in 2008 and a Master of Health Administration (MHA) from Eastern Michigan University in 2014. He is currently working on his dissertation for a Ph.D. in Healthcare Administration. Nicholas began teaching at Oakland Community College with their Respiratory Therapy Program as an Adjunct Professor. Most recently, he taught at Monroe County Community College for seven years, four years as the DCE and three years as the Program Director. Nicholas is an active member in the Michigan Society for Respiratory Care (MSRC) where he serves as the Education Chair-Elect and is on the Sputum Bowl Committee.
sjspau@umflint.edu
Shane Spaulding, MHPE, RRT, RRT-ACCS
Clinical Assistant Professor and Clinical Education Coordinator
Education: MHPE, RRT, RRT-ACCS
Shane J. Spaulding, MHPE, RRT, RRT-ACCS is the Clinical Education Coordinator and Clinical Assistant Professor for the University of Michigan-Flint Bachelor of Science in Respiratory Therapy (BSRT) degree advancement program. He obtained his respiratory therapy training at Monroe County Community College in Southeastern Michigan. He obtained his B.A. from the College of William and Mary and earned his MHPE (Health Professions Education) from Michigan State University. Before joining the University of Michigan-Flint, he taught for seven years at the Monroe County Community College, three of them as the DCE for the program. Shane brings a student-centered, community engaged approach to his educational philosophy.
dpanzlau@umflint.edu
David Panzlau, MA, RRT, RRT-NPS, RRT-ACCS
Education: BS in Health Care Education, MA in Educational Leadership
David L. Panzlau, MA, RRT, RRT-NPS, RRT-ACCS, is a faculty member in the Bachelor of Science in Respiratory Therapy Program at the University of Michigan-Flint. He taught for thirty-two years in the Associate Degree RT program at Mott Community College in Flint. He served as the Program Director for twenty-seven of those years. Upon his retirement, he was awarded Professor Emeritus status for his contributions to the program and college community. David helped lay the foundation for the BSRT program at UM-Flint and taught its first online RT class in the fall semester of 2017. He obtained his BS degree in Health Care Education in 1983 and his MA degree in Educational Leadership in 1991 from Eastern Michigan University. David first joined the AARC and MSRC (Michigan Society for Respiratory Care) in 1979 and continues to be an active member.
sgparker@umflint.edu
Sarah Parker, MAOM, RRT, RRT-NPS
Education: MAOM, RRT, RR-NPS
Sarah G. Parker, MAOM, RRT, RRT-NPS, is a faculty member of the Bachelor of Science in Respiratory Therapy (BSRT) Program at the University of Michigan-Flint. She is a Clinical Supervisor at C.S. Mott Children's Hospital - University of Michigan. Sarah received her Respiratory therapy degree at Jackson College and completed the Neonatal/Pediatric Specialty. She obtained her Masters in Organization Management (MAOM) through Spring Arbor University. She has taught the Neonatal/Pediatric Respiratory Care course for the Associate degree program at Jackson College for the previous six years and now teaches the Neonatal/Pediatric course for the University of Michigan-Flint BSRT program. Sarah is an active member in the Michigan Society for Respiratory Care (MSRC) House of Representatives where she serves as the Neonatal/Pediatric Chair.
Jan Fields, Ed.D, Ph.D., RRT, AE-C, PMP
Education: Ed.D., Ph.D., RRT, AE-C, PMP
Jan K. Fields, Ed.D, Ph.D., RRT, AE-C, PMP, is a faculty member in the Bachelor of Science in Respiratory Therapy Program at the University of Michigan-Flint. He was the Director of Clinical Education for the respiratory program at Muskegon Community College from 1988 to 2010. He earned his Masters in Management degree at Aquinas College in Grand Rapids, and both his Ed.D in Educational Leadership and Ph.D. in Interdisciplinary Evaluation at Western Michigan University. After a two-year post-doc evaluation fellowship at the CDC's National Asthma Control Program in Atlanta, he joined the Prescription Drug Overdose Prevention Program in MDHHS as program evaluator/team coordinator and continues to work in that position today. Jan first joined the AARC and MSRC (Michigan Society for Respiratory Care) in 1980 and continues to be an active member.