
    gv                     8   d Z ddlZddlZddlZddlZddlZddlZddlZddlm	Z	 ddl
Z
ddlmZ ddlmZ ddlmZ ddlmZ dZ ej(                  eej*                        Zd	Z ej(                  e      Zh d
Zh dZd Z	 d!dZd Zd"dZd Zd#dZ d$dZ!	 	 	 	 	 	 	 	 	 d%dZ"	 d&dZ#d$dZ$d$dZ%d'dZ&d Z'd!dZ(d Z)d$dZ*e+dk(  rTddl,m-Z- ddl.m/Z/m0Z0 ddl1m2Z2 dd l3m4Z4m5Z5 e0jl                  Z7 e2 e-             jl                  Z8e/jl                  Z9 e$e7       yy)(z)
Utility methods for Sentiment Analysis.
    N)deepcopy) CategorizedPlaintextCorpusReader)load)PunktTokenizer)EMOTICON_REz
    (?:
        ^(?:never|no|nothing|nowhere|noone|none|not|
            havent|hasnt|hadnt|cant|couldnt|shouldnt|
            wont|wouldnt|dont|doesnt|didnt|isnt|arent|aint
        )$
    )
    |
    n'tz	^[.:;!?]$>.   8):):*:3:>:D:P:]:b:p:};)<3=)=3=D=]=p8-D:'):-):-D:-P:-b:-p:^):^*:c):o)=-3=-D>:)>:P>;)X-DX-Px-Dx-p:'-):-))>:-)8DXDXPxDxp>   :(:<:@:L:S:[:\:c:{;(=/=L=\:'(:-(:-/:-<:-[:-c>.<>:(>:/>:[>:\:'-(:-||c                       fd}|S )zH
    A timer decorator to measure execution performance of methods.
    c                  n   t        j                          } 	| i |}t        j                          }||z
  }|dz  }|dz  dz  }t        t        |dz              }|dk(  r3|dk(  r.|dk  r)t        d	j                   d	j                  dd       |S t        d	j                   d| d	| d
| d	       |S )Ni  <   r   
   z[TIMER] z(): z.3fz secondszh zm s)timeintroundprint__name__)
argskwstartresultendtot_timehoursminssecsmethods
            H/var/www/openai/venv/lib/python3.12/site-packages/nltk/sentiment/util.pytimedztimer.<locals>.timed   s    		$$iik;D 2~"5B'(A:$!)r	HV__-T&//#1FhOP  HV__-T%4&4&JK     )rc   re   s   ` rd   timerrh      s    
 Lrf   c                 Z    i }|rt        |       } |D ]  }|t        |       v |d| d<    |S )a  
    Populate a dictionary of unigram features, reflecting the presence/absence in
    the document of each of the tokens in `unigrams`.

    :param document: a list of words/tokens.
    :param unigrams: a list of words/tokens whose presence/absence has to be
        checked in `document`.
    :param handle_negation: if `handle_negation == True` apply `mark_negation`
        method to `document` before checking for unigram presence/absence.
    :return: a dictionary of unigram features {unigram : boolean}.

    >>> words = ['ice', 'police', 'riot']
    >>> document = 'ice is melting due to global warming'.split()
    >>> sorted(extract_unigram_feats(document, words).items())
    [('contains(ice)', True), ('contains(police)', False), ('contains(riot)', False)]
    	contains())mark_negationset)documentunigramshandle_negationfeatureswords        rd   extract_unigram_featsrs      sA    " H *(,H(=9TF!$% Orf   c                 f    i }|D ])  }|t        j                  |       v |d|d    d|d    d<   + |S )a,  
    Populate a dictionary of bigram features, reflecting the presence/absence in
    the document of each of the tokens in `bigrams`. This extractor function only
    considers contiguous bigrams obtained by `nltk.bigrams`.

    :param document: a list of words/tokens.
    :param unigrams: a list of bigrams whose presence/absence has to be
        checked in `document`.
    :return: a dictionary of bigram features {bigram : boolean}.

    >>> bigrams = [('global', 'warming'), ('police', 'prevented'), ('love', 'you')]
    >>> document = 'ice is melting due to global warming'.split()
    >>> sorted(extract_bigram_feats(document, bigrams).items()) # doctest: +NORMALIZE_WHITESPACE
    [('contains(global - warming)', True), ('contains(love - you)', False),
    ('contains(police - prevented)', False)]
    rj   r   z -    rk   )nltkbigrams)rn   rw   rq   bigrs       rd   extract_bigram_featsry      sG    " H7;t||H?U7U9T!WISa	34 Orf   c                 t   |st        |       } | xr t        | d   t        t        f      }|r| d   }n| }d}t	        |      D ]s  \  }}t
        j                  |      r|r|r|r| }%||xx   dz  cc<   3|rt        j                  |      r| }N|sQt        j                  |      rg||xx   dz  cc<   u | S )a.  
    Append _NEG suffix to words that appear in the scope between a negation
    and a punctuation mark.

    :param document: a list of words/tokens, or a tuple (words, label).
    :param shallow: if True, the method will modify the original document in place.
    :param double_neg_flip: if True, double negation is considered affirmation
        (we activate/deactivate negation scope every time we find a negation).
    :return: if `shallow == True` the method will modify the original document
        and return it. If `shallow == False` the method will return a modified
        document, leaving the original unmodified.

    >>> sent = "I didn't like this movie . It was bad .".split()
    >>> mark_negation(sent)
    ['I', "didn't", 'like_NEG', 'this_NEG', 'movie_NEG', '.', 'It', 'was', 'bad', '.']
    r   F_NEG)r   
isinstancetuplelist	enumerateNEGATION_REsearchCLAUSE_PUNCT_RE)rn   double_neg_flipshallowlabeleddoc	neg_scopeirr   s           rd   rl   rl      s    " H%A:hqkE4=AGqkIS>4d# )M	A& ?11$7%I55d;FfF " Orf   c           	         t        j                  | d      5 }d}|dj                  t        j                  d            z  }t        |      D ]  }t        ||   t              r.||   }|d| dz  }t        |      D ]  }|d| d||    d	z  } Dt        ||   t              r|d| dz  }||   D ]  }|d| d
z  } t|d| d||    d	z  } |j                  |       ddd       y# 1 sw Y   yxY w)z4
    Write the output of an analysis to a file.
    atz
*** 

z{} 

z%d/%m/%Y, %H:%Mz  - **z:**
z    - : z 

z:** N)
codecsopenformatrU   strftimesortedr|   dictr~   write)filenamekwargsoutfiletextk
dictionaryentrys          rd   output_markdownr      s    
Xt	$	  /@!ABBA&)T*#AY
&5))#J/EfUG2j.?-@DDD 0F1It,&5))#AYEfUG2..D ' &4q	{#66   	d 
%	$	$s   CC++C4c                     t        j                  d       t        j                  |        |r|t        |       kD  rt        |       }| dt	        d|z         }| t	        d|z        | }||fS )at  
    Randomly split `n` instances of the dataset into train and test sets.

    :param all_instances: a list of instances (e.g. documents) that will be split.
    :param n: the number of instances to consider (in case we want to use only a
        subset).
    :return: two lists of instances. Train set is 8/10 of the total and test set
        is 2/10 of the total.
    i90  Ng?)randomseedshufflelenrV   )all_instancesn	train_settest_sets       rd   split_train_testr     sh     KK
NN=!C&&nC!G-ISq\A.Hhrf   c                    	 dd l m} |j                  dd       |j	                         }|j
                  j                          |j                  | |dd       |j                  d	d
       |j                  d       |r|j                  | |d       |r|j                  g d|d       |j                  d       |j                          y # t        $ r}t        d      |d }~ww xY w)Nr   zQThe plot function requires matplotlib to be installed.See https://matplotlib.org/y   )axisnbinsrored)colorg333333g333333?)yminymax   )padvertical)rotation)r   ru   
horizontalg?)matplotlib.pyplotpyplotImportErrorlocator_paramsaxesyaxisgridplotylimtight_layoutxticksyticksmarginsshow)x_valuesy_valuesx_labelsy_labelsplter   s          rd   
_show_plotr   *  s    ' Cq)88:DJJOOHHXxUH3HH$SH!

8X

;

:x,
?KKHHJ%  *
 	s   C 	C)C$$C)c           
         t        j                  | |      5 }t        ||||      \  }}|j                  |       |
dk(  rg }d}|D ]U  }t	        j
                  |      }t        ||      }	 ||j                  d         }|dk(  rt        j                  d|      rV|dk(  rt        j                  d|      rr|dk(  r<t        j                  |      }|r%t        |      t        z  rt        |      t        z  r|	dk(  r=t        j                  ddt        j                  d	|            ||j                  d      <   |
dk(  r;||j                  d         v r|j!                  ||j                  d                |j                  |       |d
z  }|sO||k\  sV n |j%                          ddd       y# t"        $ r Y Hw xY w# 1 sw Y   yxY w)a  
    Convert json file to csv file, preprocessing each row to obtain a suitable
    dataset for tweets Semantic Analysis.

    :param json_file: the original json file containing tweets.
    :param outfile: the output csv filename.
    :param fields: a list of fields that will be extracted from the json file and
        kept in the output csv file.
    :param encoding: the encoding of the files.
    :param errors: the error handling strategy for the output writer.
    :param gzip_compress: if True, create a compressed GZIP file.

    :param skip_retweets: if True, remove retweets.
    :param skip_tongue_tweets: if True, remove tweets containing ":P" and ":-P"
        emoticons.
    :param skip_ambiguous_tweets: if True, remove tweets containing both happy
        and sad emoticons.
    :param strip_off_emoticons: if True, strip off emoticons from all tweets.
    :param remove_duplicates: if True, remove tweets appearing more than once.
    :param limit: an integer to set the number of tweets to convert. After the
        limit is reached the conversion will stop. It can be useful to create
        subsets of the original tweets json data.
    )encodingTr   r   z\bRT\bz\:\-?P\bz	(?!\n)\s+  ru   N)r   r   _outf_writerwriterowjsonloadsextract_fieldsindexrer   r   findallrm   HAPPYSADsubappend
ValueErrorclose)	json_filer   fieldsr   errorsgzip_compressskip_retweetsskip_tongue_tweetsskip_ambiguous_tweetsstrip_off_emoticonsremove_duplicateslimitfpwriteroutftweets_cacher   linetweetrowr   all_emoticonss                         rd   json2csv_preprocessr   G  s   J 
Y	2b%gxO$LDJJt$E /C6<</0 D(yyD1 %-yyd3 (D0$/$7$7$=M$.6S=ORU=U$&$.02$c;??2t+D1CV,- %,6<</0L@ $++CV0D,EF OOC FAeG H 	

Y 
3	2L  M 
3	2sn   AG,/F8GF87G8A F88G9AF8G#F8;GGG8	GGGGGc           	         g }|s
t               }t        j                  | d      5 }t        j                  |      }|dk(  rt        |d       d}|D ]{  \  }	}
|dz  }t        j                  j                  d| d       |r7|j                  |
      D cg c]  }|j                  |      D ]  }|  }}}n|
}|j                  ||f       } 	 ddd       t        d d       |S c c}}w # 1 sw Y    xY w)	a  
    Parse csv file containing tweets and output data a list of (text, label) tuples.

    :param filename: the input csv filename.
    :param label: the label to be appended to each tweet contained in the csv file.
    :param word_tokenizer: the tokenizer instance that will be used to tokenize
        each sentence into tokens (e.g. WordPunctTokenizer() or BlanklineTokenizer()).
        If no word_tokenizer is specified, tweets will not be tokenized.
    :param sent_tokenizer: the tokenizer that will be used to split each tweet into
        sentences.
    :param skip_header: if True, skip the first line of the csv file (which usually
        contains headers).

    :return: a list of (text, label) tuples.
    rtTNr   ru   zLoaded z tweetsz tweets)r   r   r   csvreadernextsysstdoutr   tokenizer   rX   )r   labelword_tokenizersent_tokenizerskip_headertweetscsvfiler   r   tweet_idr   sentwr   s                 rd   parse_tweets_setr    s   $ F')	Xt	$G$$$NHdFAJJwqc34 !/ 7 7 = =+44T: :  =   MM5%.) % 
%( 
GA3g
M 
%	$s   A/C.C(
3C.(C..C7c           	      D   ddl m}m} ddlm} ddlm}  |d      }|t        |dz        }d	d
g}|j                  d      }	d}
t        |	|
||       |j                  d      }d}t        ||||       t        |d|      }t        |
d|      }t        |      \  }}t        |      \  }}||z   }||z   } |       }|j                  |      D cg c]  }| }}|j                  |d      }|j                  t        |       |j!                  |D cg c]  }|d   	 c}dd      }|j                  t"        |       |j%                  |      }|j%                  |      }|j'                  | |      }	 |j)                          |j/                  |      }|r]|j0                  D cg c]  }|j2                   } }t5        |dt7        |      j2                  |j8                  j2                  | ||       yyc c}w c c}w # t*        $ r t-        d       Y w xY wc c}w )a  
    Train and test Naive Bayes classifier on 10000 tweets, tokenized using
    TweetTokenizer.
    Features are composed of:

    - 1000 most frequent unigrams
    - 100 top bigrams (using BigramAssocMeasures.pmi)

    :param trainer: `train` method of a classifier.
    :param n_instances: the number of total tweets that have to be used for
        training and testing. Tweets will be equally split between positive and
        negative.
    :param output: the output file where results have to be reported.
    r   )	stopwordstwitter_samplesSentimentAnalyzer)TweetTokenizerF)preserve_caseN   idr   positive_tweets.jsonpositive_tweets.csv)r   negative_tweets.jsonnegative_tweets.csvneg)r   r   posi  )top_nro   d      )r  min_freq)rw   KYour classifier does not provide a show_most_informative_features() method.labeled_tweetsDataset
Classifier	TokenizerFeatsResults	Instances)nltk.corpusr  r  nltk.sentimentr  nltk.tokenizer  rV   abspathr   r  r   	all_wordsunigram_word_featsadd_feat_extractorrs   bigram_collocation_featsry   apply_featurestrainshow_most_informative_featuresAttributeErrorrX   evaluatefeat_extractorsrY   r   type	__class__)!trainern_instancesoutputr  r  r  r  	tokenizerr   positive_jsonpositive_csvnegative_jsonnegative_csvneg_docspos_docstrain_pos_docstest_pos_docstrain_neg_docstest_neg_docstraining_tweetstesting_tweetssentim_analyzerrr   r#  unigram_featsr   bigram_collocs_featstraining_setr   
classifierresultsfextrs!                                    rd   demo_tweetsrG    sS    70, U3I +/*F^F#++,BCM(L|V;O#++,BCM(L|V;OE)THE)TH %5X$>!NM$4X$>!NM$~5O"]2N')O #2";";O"LM"L$"LIM $66y6MM&&'<}&U +CC./eq/sR D  &&&: '  #11/BL--n=H &&w=J
113
 &&x0G$3$C$CD$Cq

$CD$J'00))22!	
 7 N 	0  
Y	

 Es$   	G9G>8H )HHHc           	         ddl m} ddlm} |t	        |dz        }|j                  d      d| D cg c]  }t        |j                  |            df  }}|j                  d      d| D cg c]  }t        |j                  |            df  }}t        |      \  }	}
t        |      \  }}|	|z   }|
|z   } |       }|j                  |      }|j                  |d	      }|j                  t        |
       |j                  |      }|j                  |      }|j                  | |      }	 |j                          |j%                  |      }|rI|j&                  D cg c]  }|j(                   }}t+        |dt-        |      j(                  d|||       yyc c}w c c}w # t         $ r t#        d       Y }w xY wc c}w )a  
    Train classifier on all instances of the Movie Reviews dataset.
    The corpus has been preprocessed using the default sentence tokenizer and
    WordPunctTokenizer.
    Features are composed of:

    - most frequent unigrams

    :param trainer: `train` method of a classifier.
    :param n_instances: the number of total reviews that have to be used for
        training and testing. Reviews will be equally split between positive and
        negative.
    :param output: the output file where results have to be reported.
    r   )movie_reviewsr  Nr	  r  r     r  r  r  Movie_reviewsWordPunctTokenizerr  )r  rI  r   r  rV   fileidsr~   wordsr   r#  r$  r%  rs   r'  r(  r)  r*  rX   r+  r,  rY   r   r-  )r/  r0  r1  rI  r  pos_idr8  neg_idr7  r9  r:  r;  r<  training_docstesting_docsr?  r#  r@  rB  r   rC  rD  rE  rF  s                           rd   demo_movie_reviewsrT  (  s    *0+/* $++E2<K@@F 
m!!&)	*E2@   $++E2<K@@F 
m!!&)	*E2@   %5X$>!NM$4X$>!NM"^3M =0L')O))-8I $66y16MM&&'<}&U"11-@L--l;H &&w=J
113
 &&x0G$3$C$CD$Cq

$CD#J'00*!	
 G2  
Y	

 Es#   #F.#F"0F' !G'F>=F>c           	         ddl m} ddlm} |t	        |dz        }|j                  d      d| D cg c]  }|df }}|j                  d      d| D cg c]  }|df }}t        |      \  }	}
t        |      \  }}|	|z   }|
|z   } |       }|j                  |D cg c]  }t        |       c}      }|j                  |d	
      }|j                  t        |       |j                  |      }|j                  |      }|j                  | |      }	 |j                          |j#                  |      }|dk(  r|j%                  |d       |rH|j&                  D cg c]  }|j(                   }}t+        |dt-        |      j(                  d|||       |S c c}w c c}w c c}w # t        $ r t!        d       Y w xY wc c}w )a  
    Train and test a classifier on instances of the Subjective Dataset by Pang and
    Lee. The dataset is made of 5000 subjective and 5000 objective sentences.
    All tokens (words and punctuation marks) are separated by a whitespace, so
    we use the basic WhitespaceTokenizer to parse the data.

    :param trainer: `train` method of a classifier.
    :param save_analyzer: if `True`, store the SentimentAnalyzer in a pickle file.
    :param n_instances: the number of total sentences that have to be used for
        training and testing. Sentences will be equally split between positive
        and negative.
    :param output: the output file where results have to be reported.
    r   )subjectivityr  Nr	  subj)
categoriesobjrJ  rK  r  r  Tsa_subjectivity.picklerV  WhitespaceTokenizer)r  r  r  r  r  r  )r  rV  r   r  rV   sentsr   r#  rl   r$  r%  rs   r'  r(  r)  r*  rX   r+  	save_filer,  rY   r   r-  )r/  save_analyzerr0  r1  rV  r  r   	subj_docsobj_docstrain_subj_docstest_subj_docstrain_obj_docstest_obj_docsrR  rS  r?  r   all_words_negr@  rB  r   rC  rD  rE  rF  s                            rd   demo_subjectivityrf  m  s    )0+/* $0#5#5#5#H+#V#V4v#V   #/"4"4"4"F|"T"T$u"T   '7y&A#O^$4X$>!NM#n4M!M1L')O#--'45}s	}5M
 $66}q6QM&&'<}&U #11-@L--l;H &&w=J
113
 &&x0G!!/3KL$3$C$CD$Cq

$CD"J'00+!	
 i 	6  
Y	

 Es)   FF"!F'F, !G,GGc                 `   ddl m} ddlm} |j	                         }	 t        d      }|j                  |       D cg c]  }|j                          }}t        |j                  |             y# t        $ r/ t        d       t        d       t        |j                  d      }Y ~w xY wc c}w )	z
    Classify a single sentence as subjective or objective using a stored
    SentimentAnalyzer.

    :param text: a sentence whose subjectivity has to be classified.
    r   )NaiveBayesClassifier)regexprZ  z4Cannot find the sentiment analyzer you want to load.z.Training a new one using NaiveBayesClassifier.TN)nltk.classifyrh  r!  ri  r[  r   LookupErrorrX   rf  r(  r   lowerclassify)r   rh  ri  r   r?  rr   tokenized_texts          rd   demo_sent_subjectivityro    s     3$//1NN78 0>/F/Ft/LM/Ltdjjl/LNM	/
"
">
23  NDE>?+,@,F,FMN Ns   A0 B+05B('B(c                 J   ddl m} ddlm} |j	                         }d}d}|j                  |       D cg c]  }|j                          }}t        t        t        |                  }	g }
|D ]e  }||j                         v r|dz  }|
j                  d       ,||j                         v r|dz  }|
j                  d       U|
j                  d       g ||kD  rt        d       n!||k  rt        d       n||k(  rt        d       |d	k(  rt        |	|
|g d
       yyc c}w )a  
    Basic example of sentiment classification using Liu and Hu opinion lexicon.
    This function simply counts the number of positive, negative and neutral words
    in the sentence and classifies it depending on which polarity is more represented.
    Words that do not appear in the lexicon are considered as neutral.

    :param sentence: a sentence whose polarity has to be classified.
    :param plot: if True, plot a visual representation of the sentence polarity.
    r   )opinion_lexicon)treebankru   r   PositiveNegativeNeutralT)rt  ru  rs  )r   r   N)r  rq  r!  rr  TreebankWordTokenizerr   rl  r~   ranger   positiver   negativerX   r   )sentencer   rq  rr  r2  	pos_words	neg_wordsrr   tokenized_sentxr   s              rd   demo_liu_hu_lexiconr    s    ,&..0III/8/A/A(/KL/Ktdjjl/KNLU3~&'(A
A?++--NIHHQK_--//NIHHRLHHQK  9j	Y	j	i	it|q>4W	
 - Ms   D c                 R    ddl m}  |       }t        |j                  |              y)z~
    Output polarity scores for a text using Vader approach.

    :param text: a text whose polarity has to be evaluated.
    r   SentimentIntensityAnalyzerN)r   r  rX   polarity_scores)r   r  vader_analyzers      rd   demo_vader_instancer    s"     :/1N	.
(
(
./rf   c                 <   ddl m} ddlm} ddlm} ddlm} ddlm} ddlm} ddl	m
} | t        | d
z        } ddg}	|j                  d      }
d}t        |
||	d|        |j                  d      }d}t        |||	d|        t        |d      }t        |d      }t        |      \  }}t        |      \  }}||z   }||z   } |       } |t               } |t               }g }g }t!               }d}t#        |      D ]  \  }\  }}|j%                  |       ||   j%                  |       |j'                  |       |j)                  |      d   } | dkD  rd}!nd}!|dz  }|j'                  |!       ||!   j%                  |        i }"|D ]X  } |||      }#|#|"d<    |||   ||         }$|$|"d| d<    |||   ||         }%|%|"d| d<    |||   ||         }&|&|"d| d<   Z t+        |"      D ]  }'t-        |' d|"|'            |rt/        |dd| |"        y	y	)!z
    Classify 10000 positive and negative tweets using Vader approach.

    :param n_instances: the number of total tweets that have to be classified.
    :param output: the output file where results have to be reported.
    r   )defaultdict)r  )accuracy)	f_measure)	precision)recallr  Nr	  r
  r   r  r  F)r   r   r  r  r  )r   r  compoundru   AccuracyzPrecision []zRecall [zF-measure [r   Vaderr  )Approachr  r  r  )collectionsr  r  r  nltk.metricsr  r  r  r  r   r  rV   r"  r   r  r   rm   r   addr   r  r   rX   r   )(r0  r1  r  r  eval_accuracyeval_f_measureeval_precisioneval_recallr  r   r3  r4  r5  r6  r8  r7  r9  r:  r;  r<  r=  r>  r  gold_resultstest_resultsacc_gold_resultsacc_test_resultslabelsnumr   r   r   scoreobservedmetrics_resultsaccuracy_scoreprecision_scorerecall_scoref_measure_scorer]   s(                                           rd   demo_vader_tweetsr    s    (+68829+/*F^F#++,BCM(L! $++,BCM(L!  E:HE:H %5X$>!NM$4X$>!NM$~5O"]2N/1Ns#Ls#LUF
C%n5=D%

5U"&..t4Z@19HHq)X""1% 6 O&'79IJ&4
#(e)<l5>QR2A+eWA./"<#6U8KL/;(5'+,(e)<l5>QR2A+eWA./  )?62345 * $!#	
 rf   __main__)	LinearSVC)MaxentClassifierrh  )SklearnClassifier)r   r   )F)FF)N)NN)	utf8replaceFTTTTTN)NNT)FNN):__doc__r   r   r   r   r   r   rU   copyr   rv   r  r   	nltk.datar   r!  r   nltk.tokenize.casualr   NEGATIONcompileVERBOSEr   CLAUSE_PUNCTr   r   r   rh   rs   ry   rl   r   r   r   r   r  rG  rT  rf  ro  r  r  r  rY   sklearn.svmr  rj  r  rh  nltk.classify.scikitlearnr  nltk.twitter.commonr   r   r(  naive_bayessvmmaxentrg   rf   rd   <module>r     sH    
   	 
    8  ( , bjj2::."**\*/	b<428&R,(B 
Qj LP+fW
tB
JHV4.)
X	0\
~ z%D;@&,,K
IK
(
.
.C##F rf   