climine 0.0.1

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.0/test/test_rake_win32.rb

@@ -0,0 +1,72 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeWin32 < Rake::TestCase
+
+  Win32 = Rake::Win32
+
+  def test_win32_system_dir_uses_home_if_defined
+    ENV['HOME'] = 'C:\\HP'
+
+    assert_equal "C:/HP/Rake", Win32.win32_system_dir
+  end
+
+  def test_win32_system_dir_uses_homedrive_homepath_when_no_home_defined
+    ENV['HOME']      = nil
+    ENV['HOMEDRIVE'] = 'C:'
+    ENV['HOMEPATH']  = '\\HP'
+
+    assert_equal "C:/HP/Rake", Win32.win32_system_dir
+  end
+
+  def test_win32_system_dir_uses_appdata_when_no_home_or_home_combo
+    ENV['APPDATA']   = "C:\\Documents and Settings\\HP\\Application Data"
+    ENV['HOME']      = nil
+    ENV['HOMEDRIVE'] = nil
+    ENV['HOMEPATH']  = nil
+
+    assert_equal "C:/Documents and Settings/HP/Application Data/Rake",
+                 Win32.win32_system_dir
+  end
+
+  def test_win32_system_dir_fallback_to_userprofile_otherwise
+    ENV['HOME']        = nil
+    ENV['HOMEDRIVE']   = nil
+    ENV['HOMEPATH']    = nil
+    ENV['APPDATA']     = nil
+    ENV['USERPROFILE'] = "C:\\Documents and Settings\\HP"
+
+    assert_equal "C:/Documents and Settings/HP/Rake", Win32.win32_system_dir
+  end
+
+  def test_win32_system_dir_nil_of_no_env_vars
+    ENV['APPDATA']     = nil
+    ENV['HOME']        = nil
+    ENV['HOMEDRIVE']   = nil
+    ENV['HOMEPATH']    = nil
+    ENV['RAKE_SYSTEM'] = nil
+    ENV['USERPROFILE'] = nil
+
+    assert_raises(Rake::Win32::Win32HomeError) do
+      Win32.win32_system_dir
+    end
+  end
+
+  def test_win32_backtrace_with_different_case
+    ex = nil
+    begin
+     raise 'test exception'
+    rescue => ex
+    end
+
+    ex.set_backtrace ['abc', 'rakefile']
+
+    rake = Rake::Application.new
+    rake.options.trace = true
+    rake.instance_variable_set(:@rakefile, 'Rakefile')
+
+    _, err = capture_io { rake.display_error_message(ex) }
+
+    assert_match(/rakefile/, err)
+  end
+
+end

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.0/test/test_thread_history_display.rb

@@ -0,0 +1,101 @@
+require File.expand_path('../helper', __FILE__)
+
+require 'rake/thread_history_display'
+
+class TestThreadHistoryDisplay < Rake::TestCase
+  def setup
+    super
+    @time = 1_000_000
+    @stats = []
+    @display = Rake::ThreadHistoryDisplay.new(@stats)
+  end
+
+  def test_banner
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/Job History/i, out)
+  end
+
+  def test_item_queued
+    @stats << event(:item_queued,  :item_id => 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +item_queued +item_id:1$/, out)
+  end
+
+  def test_item_dequeued
+    @stats << event(:item_dequeued,  :item_id => 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +item_dequeued +item_id:1$/, out)
+  end
+
+  def test_multiple_items
+    @stats << event(:item_queued,  :item_id => 123)
+    @stats << event(:item_queued,  :item_id => 124)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +item_queued +item_id:1$/, out)
+    assert_match(/^ *1000001 +A +item_queued +item_id:2$/, out)
+  end
+
+  def test_waiting
+    @stats << event(:waiting, :item_id => 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +waiting +item_id:1$/, out)
+  end
+
+  def test_continue
+    @stats << event(:continue, :item_id => 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +continue +item_id:1$/, out)
+  end
+
+  def test_thread_deleted
+    @stats << event(
+      :thread_deleted,
+      :deleted_thread => 123_456,
+      :thread_count => 12)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(
+      /^ *1000000 +A +thread_deleted( +deleted_thread:B| +thread_count:12){2}$/,
+      out)
+  end
+
+  def test_thread_created
+    @stats << event(
+      :thread_created,
+      :new_thread => 123_456,
+      :thread_count => 13)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(
+      /^ *1000000 +A +thread_created( +new_thread:B| +thread_count:13){2}$/,
+      out)
+  end
+
+  private
+
+  def event(type, data = {})
+    result = {
+      :event => type,
+      :time  => @time / 1_000_000.0,
+      :data  => data,
+      :thread => Thread.current.object_id
+    }
+    @time += 1
+    result
+  end
+
+end

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.0/test/test_trace_output.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../helper', __FILE__)
+require 'stringio'
+
+class TestTraceOutput < Rake::TestCase
+  include Rake::TraceOutput
+
+  class PrintSpy
+    attr_reader :result, :calls
+
+    def initialize
+      @result = ""
+      @calls = 0
+    end
+
+    def print(string)
+      @result << string
+      @calls += 1
+    end
+  end
+
+  def test_trace_issues_single_io_for_args_with_empty_args
+    spy = PrintSpy.new
+    trace_on(spy)
+    assert_equal "\n", spy.result
+    assert_equal 1, spy.calls
+  end
+
+  def test_trace_issues_single_io_for_args_multiple_strings
+    spy = PrintSpy.new
+    trace_on(spy, "HI\n", "LO")
+    assert_equal "HI\nLO\n", spy.result
+    assert_equal 1, spy.calls
+  end
+
+  def test_trace_handles_nil_objects
+    spy = PrintSpy.new
+    trace_on(spy, "HI\n", nil, "LO")
+    assert_equal "HI\nLO\n", spy.result
+    assert_equal 1, spy.calls
+  end
+
+  def test_trace_issues_single_io_for_args_multiple_strings_and_alternate_sep
+    old_sep = $\
+    $\ = "\r"
+    spy = PrintSpy.new
+    trace_on(spy, "HI\r", "LO")
+    assert_equal "HI\rLO\r", spy.result
+    assert_equal 1, spy.calls
+  ensure
+    $\ = old_sep
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/redcarpet-3.0.0/COPYING

@@ -0,0 +1,14 @@
+Copyright (c) 2009, Natacha Porté
+Copyright (c) 2011, Vicent Marti
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/vendor/bundle/ruby/2.0.0/gems/redcarpet-3.0.0/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org/"
+gemspec

data/vendor/bundle/ruby/2.0.0/gems/redcarpet-3.0.0/README.markdown

@@ -0,0 +1,364 @@
+Redcarpet 2 is written with sugar, spice and everything nice
+============================================================
+
+[![Build Status](https://travis-ci.org/vmg/redcarpet.png?branch=master)](https://travis-ci.org/vmg/redcarpet)
+
+Redcarpet is Ruby library for Markdown processing that smells like
+butterflies and popcorn.
+
+Redcarpet used to be a drop-in replacement for Redcloth. This is no longer the
+case since version 2 -- it now has its own API, but retains the old name. Yes,
+that does mean that Redcarpet 2 is not backwards-compatible with the 1.X
+versions.
+
+Redcarpet is based on the [Sundown](https://www.github.com/vmg/sundown)
+library. You might want to find out more about Sundown to see what makes this
+Ruby library so awesome.
+
+This library is written by people
+---------------------------------
+
+Redcarpet 2 has been rewritten from scratch by Vicent Martí (@vmg). Why
+are you not following me on Twitter?
+
+Redcarpet would not be possible without the Sundown library and its authors
+(Natacha Porté, Vicent Martí, and its many awesome contributors).
+
+You can totally install it as a Gem
+-----------------------------------
+
+Redcarpet is readily available as a Ruby gem. It will build some native
+extensions, but the parser is standalone and requires no installed libraries.
+Redcarpet requires at least Ruby 1.9.2 on your system.
+
+    $ [sudo] gem install redcarpet
+
+The Redcarpet source is available at GitHub:
+
+    $ git clone git://github.com/vmg/redcarpet.git
+
+And it's like *really* simple to use
+------------------------------------
+
+The core of the Redcarpet library is the `Redcarpet::Markdown` class. Each
+instance of the class is attached to a `Renderer` object; the Markdown class
+performs parsing of a document and uses the attached renderer to generate
+output.
+
+The `Markdown` object is encouraged to be instantiated once with the required
+settings, and reused between parses.
+
+~~~~~ ruby
+# Initializes a Markdown parser
+Markdown.new(renderer, extensions = {})
+~~~~~
+
+
+Here, the `renderer` variable refers to a renderer object, inheriting
+from `Redcarpet::Render::Base`. If the given object has not been
+instantiated, the library will do it with default arguments.
+
+You can also specify a hash containing the Markdown extensions which the
+parser will identify. The following extensions are accepted:
+
+* `:no_intra_emphasis`: do not parse emphasis inside of words.
+Strings such as `foo_bar_baz` will not generate `<em>` tags.
+
+* `:tables`: parse tables, PHP-Markdown style.
+
+* `:fenced_code_blocks`: parse fenced code blocks, PHP-Markdown
+style. Blocks delimited with 3 or more `~` or backtickswill be considered
+as code, without the need to be indented. An optional language name may
+be added at the end of the opening fence for the code block.
+
+* `:autolink`: parse links even when they are not enclosed in `<>`
+characters. Autolinks for the http, https and ftp protocols will be
+automatically detected. Email addresses are also handled, and http
+links without protocol, but starting with `www`.
+
+* `:disable_indented_code_blocks`: do not parse usual markdown
+code blocks. Markdown converts text with four spaces at
+the front of each line to code blocks. This options
+prevents it from doing so. Recommended to use
+with `fenced_code_blocks: true`.
+
+* `:strikethrough`: parse strikethrough, PHP-Markdown style
+Two `~` characters mark the start of a strikethrough,
+e.g. `this is ~~good~~ bad`.
+
+* `:lax_spacing`: HTML blocks do not require to be surrounded by an
+empty line as in the Markdown standard.
+
+* `:space_after_headers`: A space is always required between the hash
+at the beginning of a header and its name, e.g. `#this is my header`
+would not be a valid header.
+
+* `:superscript`: parse superscripts after the `^` character; contiguous superscripts are nested together, and complex values can be enclosed in parenthesis, e.g. `this is the 2^(nd) time`
+
+* `:underline`: parse underscored emphasis as underlines.
+`This is _underlined_ but this is still *italic*`.
+
+* `:highlight`: parse highlights.
+`This is ==highlighted==`. It looks like this: `<mark>highlighted</mark>`
+
+Example:
+
+~~~~~ ruby
+markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :autolink => true, :space_after_headers => true)
+~~~~~
+
+Rendering with the `Markdown` object is done through `Markdown#render`.
+Unlike in the RedCloth API, the text to render is passed as an argument
+and not stored inside the `Markdown` instance, to encourage reusability.
+Example:
+
+~~~~~ ruby
+markdown.render("This is *bongos*, indeed.")
+# => "<p>This is <em>bongos</em>, indeed</p>"
+~~~~~
+
+
+Darling, I packed you a couple renderers for lunch
+--------------------------------------------------
+
+Redcarpet comes with two built-in renderers, `Redcarpet::Render::HTML` and
+`Redcarpet::Render::XHTML`, which output HTML and XHTML, respectively. These
+renderers are actually implemented in C and hence offer brilliant
+performance — several degrees of magnitude faster than other Ruby Markdown
+solutions.
+
+All the rendering flags that previously applied only to HTML output have
+now been moved to the `Redcarpet::Render::HTML` class, and may be enabled when
+instantiating the renderer:
+
+~~~~~ ruby
+Redcarpet::Render::HTML.new(render_options = {})
+~~~~~
+
+Initializes an HTML renderer. The following flags are available:
+
+* `:filter_html`: do not allow any user-inputted HTML in the output.
+
+* `:no_images`: do not generate any `<img>` tags.
+
+* `:no_links`: do not generate any `<a>` tags.
+
+* `:no_styles`: do not generate any `<style>` tags.
+
+* `:safe_links_only`: only generate links for protocols which are considered
+safe.
+
+* `:with_toc_data`: add HTML anchors to each header in the output HTML,
+to allow linking to each section.
+
+* `:hard_wrap`: insert HTML `<br>` tags inside on paragraphs where the origin
+Markdown document had newlines (by default, Markdown ignores these newlines).
+
+* `:xhtml`: output XHTML-conformant tags. This option is always enabled in the
+`Render::XHTML` renderer.
+
+* `:prettify`: add prettyprint classes to `<code>` tags for google-code-prettify.
+
+* `:link_attributes`: hash of extra attributes to add to links.
+
+Example:
+
+~~~~~ ruby
+renderer = Redcarpet::Render::HTML.new(:no_links => true, :hard_wrap => true)
+~~~~~
+
+
+The `HTML` renderer has an alternate version, `Redcarpet::Render::HTML_TOC`,
+which will output a table of contents in HTML based on the headers of the
+Markdown document.
+
+Furthermore, the abstract base class `Redcarpet::Render::Base` can be used
+to write a custom renderer purely in Ruby, or extending an existing renderer.
+See the following section for more information.
+
+
+And you can even cook your own
+------------------------------
+
+Custom renderers are created by inheriting from an existing renderer. The
+built-in renderers, `HTML` and `XHTML` may be extended as such:
+
+~~~~~ ruby
+# create a custom renderer that allows highlighting of code blocks
+class HTMLwithPygments < Redcarpet::Render::HTML
+  def block_code(code, language)
+    Pygments.highlight(code, :lexer => language)
+  end
+end
+
+markdown = Redcarpet::Markdown.new(HTMLwithPygments, :fenced_code_blocks => true)
+~~~~~
+
+But new renderers can also be created from scratch (see `lib/redcarpet/render_man.rb` for
+an example implementation of a Manpage renderer)
+
+~~~~~~ ruby
+class ManPage < Redcarpet::Render::Base
+  # you get the drill -- keep going from here
+end
+~~~~~
+
+The following instance methods may be implemented by the renderer:
+
+### Block-level calls
+
+If the return value of the method is `nil`, the block will be skipped.
+If the method for a document element is not implemented, the block will
+be skipped.
+
+Example:
+
+~~~~ ruby
+class RenderWithoutCode < Redcarpet::Render::HTML
+  def block_code(code, language)
+    nil
+  end
+end
+~~~~
+
+* block_code(code, language)
+* block_quote(quote)
+* block_html(raw_html)
+* header(text, header_level)
+* hrule()
+* list(contents, list_type)
+* list_item(text, list_type)
+* paragraph(text)
+* table(header, body)
+* table_row(content)
+* table_cell(content, alignment)
+
+### Span-level calls
+
+A return value of `nil` will not output any data. If the method for
+a document element is not implemented, the contents of the span will
+be copied verbatim:
+
+* autolink(link, link_type)
+* codespan(code)
+* double_emphasis(text)
+* emphasis(text)
+* image(link, title, alt_text)
+* linebreak()
+* link(link, title, content)
+* raw_html(raw_html)
+* triple_emphasis(text)
+* strikethrough(text)
+* superscript(text)
+* underline(text)
+* highlight(text)
+
+### Low level rendering
+
+* entity(text)
+* normal_text(text)
+
+### Header of the document
+
+Rendered before any another elements:
+
+* doc_header()
+
+### Footer of the document
+
+Rendered after all the other elements:
+
+* doc_footer()
+
+### Pre/post-process
+
+Special callback: preprocess or postprocess the whole document before
+or after the rendering process begins:
+
+* preprocess(full_document)
+* postprocess(full_document)
+
+You can look at
+["How to extend the Redcarpet 2 Markdown library?"](http://dev.af83.com/2012/02/27/howto-extend-the-redcarpet2-markdown-lib.html)
+for some more explanations.
+
+Also, now our Pants are much smarter
+------------------------------------
+
+Redcarpet 2 comes with a standalone [SmartyPants](
+http://daringfireball.net/projects/smartypants/) implementation. It is fully
+compliant with the original implementation. It is the fastest SmartyPants
+parser there is, with a difference of several orders of magnitude.
+
+The SmartyPants parser can be found in `Redcarpet::Render::SmartyPants`. It has
+been implemented as a module, so it can be used standalone or as a mixin.
+
+When mixed with a Renderer class, it will override the `postprocess` method
+to perform SmartyPants replacements once the rendering is complete.
+
+~~~~ ruby
+# Mixin
+class HTMLWithPants < Redcarpet::Render::HTML
+  include Redcarpet::Render::SmartyPants
+end
+
+# Standalone
+Redcarpet::Render::SmartyPants.render("<p>Oh SmartyPants, you're so crazy...</p>")
+~~~~~
+
+SmartyPants works on top of already-rendered HTML, and will ignore replacements
+inside the content of HTML tags and inside specific HTML blocks such as
+`<code>` or `<pre>`.
+
+What? You really want to mix Markdown renderers?
+------------------------------------------------
+
+What a terrible idea! Markdown is already ill-specified enough; if you create
+software that is renderer-independent, the results will be completely unreliable!
+
+Each renderer has its own API and its own set of extensions: you should choose one
+(it doesn't have to be Redcarpet, though that would be great!), write your
+software accordingly, and force your users to install it. That's the
+only way to have reliable and predictable Markdown output on your program.
+
+Still, if major forces (let's say, tornadoes or other natural disasters) force you
+to keep a Markdown-compatibility layer, Redcarpet also supports this:
+
+~~~~~ ruby
+require 'redcarpet/compat'
+~~~~~
+
+Requiring the compatibility library will declare a `Markdown` class with the
+classical RedCloth API, e.g.
+
+~~~~~ ruby
+Markdown.new('this is my text').to_html
+~~~~~
+
+This class renders 100% standards compliant Markdown with 0 extensions. Nada.
+Don't even try to enable extensions with a compatibility layer, because
+that's a maintenance nightmare and won't work.
+
+On a related topic: if your Markdown gem has a `lib/markdown.rb` file that
+monkeypatches the Markdown class, you're a terrible human being. Just saying.
+
+Testing
+-------
+Tests run a lot faster without `bundle exec` :)
+
+Boring legal stuff
+------------------
+
+Copyright (c) 2011, Vicent Martí
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/vendor/bundle/ruby/2.0.0/gems/redcarpet-3.0.0/Rakefile

@@ -0,0 +1,57 @@
+require 'date'
+require 'rake/clean'
+require 'rake/extensiontask'
+require 'digest/md5'
+
+task :default => [:test]
+
+# Ruby Extension
+Rake::ExtensionTask.new('redcarpet')
+
+# Packaging
+require 'bundler/gem_tasks'
+
+# Testing
+require 'rake/testtask'
+
+Rake::TestTask.new('test:unit') do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+  t.warning = false
+end
+
+task 'test:unit' => :compile
+
+desc 'Run conformance tests (MARKDOWN_TEST_VER=1.0)'
+task 'test:conformance' => :compile do |t|
+  script = "#{pwd}/bin/redcarpet"
+  test_version = ENV['MARKDOWN_TEST_VER'] || '1.0.3'
+  lib_dir = "#{pwd}/lib"
+
+  chdir("test/MarkdownTest_#{test_version}") do
+    sh "RUBYLIB=#{lib_dir} ./MarkdownTest.pl --script='#{script}' --tidy"
+  end
+end
+
+desc 'Run version 1.0 conformance suite'
+task 'test:conformance:1.0' => :compile do |t|
+  ENV['MARKDOWN_TEST_VER'] = '1.0'
+  Rake::Task['test:conformance'].invoke
+end
+
+desc 'Run 1.0.3 conformance suite'
+task 'test:conformance:1.0.3' => :compile do |t|
+  ENV['MARKDOWN_TEST_VER'] = '1.0.3'
+  Rake::Task['test:conformance'].invoke
+end
+
+desc 'Run unit and conformance tests'
+task :test => %w[test:unit test:conformance]
+
+desc 'Run benchmarks'
+task :benchmark => :compile do |t|
+  $:.unshift 'lib'
+  load 'test/benchmark.rb'
+end

data/vendor/bundle/ruby/2.0.0/gems/redcarpet-3.0.0/bin/redcarpet

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# Usage: redcarpet [--parse-<extension>...] [--render-<extension>...] [--smarty] [<file>...]
+# Convert one or more Markdown files to HTML and write to standard output. With
+# no <file> or when <file> is '-', read Markdown source text from standard input.
+# With <extension>s, perform additional Markdown processing before writing output.
+# With --smarty, use the SmartyHTML renderer
+if ARGV.include?('--help')
+  File.read(__FILE__).split("\n").grep(/^# /).each do |line|
+    puts line[2..-1]
+  end
+  exit 0
+end
+
+root = File.expand_path('../../', __FILE__)
+$:.unshift File.expand_path('lib', root)
+
+require 'redcarpet'
+
+render_extensions = {}
+parse_extensions = {}
+renderer = Redcarpet::Render::HTML
+
+ARGV.delete_if do |arg|
+  if arg =~ /^--render-([\w-]+)$/
+    arg = $1.gsub('-', '_')
+    render_extensions[arg.to_sym] = true
+  elsif arg =~ /^--parse-([\w-]+)$/
+    arg = $1.gsub('-', '_')
+    parse_extensions[arg.to_sym] = true
+  elsif arg == '--smarty'
+    renderer = Redcarpet::Render::SmartyHTML
+  else
+    false
+  end
+end
+
+render = renderer.new(render_extensions)
+STDOUT.write(Redcarpet::Markdown.new(render, parse_extensions).render(ARGF.read))