text:
Rails generators with coredata model

## Installation

Add this line to your application's Gemfile:

    gem 'rails_coredata-generators', :group => :development

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install rails_coredata-generators

## Usage

    $ rails generate rails_coredata:scaffold path/to/data.xcdatamodeld

OR

    $ rails generate rails_coredata:model path/to/data.xcdatamodeld
    $ rails generate rails_coredata:controller path/to/data.xcdatamodeld
    $ rails generate rails_coredata:serializer path/to/data.xcdatamodeld

### Overwrite template files

    $ rake rails_coredata:templates:copy

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request


text:
/**
 * Module dependencies.
 */

var express = require('express')
  , http = require('http')
  , net = require('net')
  , path = require('path');

var async = require('async');

var app = express();

var file = require('./lib/file.js')
  , diff = require('./lib/diff.js');

app.configure(function() {
  app.set('port', process.env.PORT || 3000);
  app.set('views', path.join(__dirname, 'app', 'views'));
  app.set('view engine', 'jade');
  app.use(express.favicon());
  app.use(express.logger('dev'));
  app.use(express.urlencoded());
  app.use(express.json());
  app.use(express.cookieParser());
  app.use(express.session({ secret: 'keyboard cat' }));
  app.use(express.methodOverride());
  app.use(express.static(path.join(__dirname, 'public')));

  // Middleware to refresh notifications
  app.use(function(req, res, next) {
    res.locals({ title: 'ace-grading' });
    next(null, req, res);
  });

  app.use(app.router);

  // Fallback to 404 if no matching route found
  app.use(function(req, res) {
    res.status(404).render('404');
  });
});

app.configure('development', function() {
  app.use(express.errorHandler());
  app.locals.pretty = true;
});

app.configure('production', function() {
  app.use(function(err, req, res, next) {
    console.error(err.stack);
    res.status(500).render('500');
  });

  app.locals.pretty = true;
});

app.get('/view', function(req, res) {
  res.render('view');
});

app.get('/compare', function(req, res) {
  res.render('compare');
});

app.post('/api/v1/view', function(req, res, next) {
  var filename = req.body.file;

  file.readlines(filename, function(err, contents) {
    if (err) {
      return next(err);
    }

    res.send({ file: { contents: contents } });
  });
});

app.post('/api/v1/compare', function(req, res, next) {
  var fromFilename = req.body.fromFile
    , toFilename = req.body.toFile;

  function doRead(filename) {
    return function(callback) {
      file.readlines(filename, callback);
    };
  };

  function doDiff(fromFilename, toFilename) {
    return function(callback) {
      diff.exec(fromFilename, toFilename, callback);
    };
  };

  function cbAlign(err, fromContents, toContents, changes) {
    if (err) {
      return next(err);
    }

    res.send({
      fromFile: { contents: fromContents }
    , toFile: { contents: toContents }
    , changes: changes
    });
  };

  var tasks = {
    from: doRead(fromFilename)
  , to: doRead(toFilename)
  , diff: doDiff(fromFilename, toFilename)
  };

  async.parallel(tasks, function(err, results) {
    if (err) {
      return next(err);
    }

    diff.align(results.from, results.to, results.diff, cbAlign);
  });
});

http.createServer(app).listen(app.get('port'), function() {
  console.log('Express server listening on port ' + app.get('port'));
});

redpajama_set_name: RedPajamaGithub


text:
BEGIN_FASTDB_NAMESPACE

class unix_socket : public socket_t {
  protected:
    int           fd;
    int           errcode;     // error code of last failed operation
    char*         address;     // host address
    socket_domain domain;      // Unix domain or INET socket
    bool          create_file; // Unix domain sockets use files for connection

    enum error_codes {
        ok = 0,
        not_opened = -1,
        bad_address = -2,
        connection_failed = -3,
        broken_pipe = -4,
        invalid_access_mode = -5
    };

  public:
    //
    // Directory for Unix Domain socket files. This directory should be
    // either empty or be terminated with "/". Dafault value is "/tmp/"
    //
    static char* unix_socket_dir;

    bool      open(int listen_queue_size);
    bool      connect(int max_attempts, time_t timeout);

    int       read(void* buf, size_t min_size, size_t max_size, time_t timeout);
    bool      write(void const* buf, size_t size, time_t timeout);

    bool      is_ok();
    bool      shutdown();
    bool      close();
    char*     get_peer_name();
    void      get_error_text(char* buf, size_t buf_size);

    socket_t* accept();
    bool      cancel_accept();

    socket_handle_t get_handle();

    unix_socket(const char* address, socket_domain domain);
    unix_socket(int new_fd);

    ~unix_socket();
};

END_FASTDB_NAMESPACE

#endif


text:
/* eslint-disable */
import React from 'react';
import expect from 'expect';
import expectJSX from 'expect-jsx';
import { shallow, mount } from 'enzyme';
import { createRenderer } from 'react-addons-test-utils';
import MDDropDownMenu from 'src/MDDropDownMenu';
import $ from 'jquery';

expect.extend(expectJSX);

describe('MDDropDownMenu', () => {
  describe('with input', () => {
    let wrapper;
    const options = ['xixi', 'haha', 'hehe'];
    before(() => {
      wrapper = shallow(
        <MDDropDownMenu
          width={50}
          height={60}
          options={options}
          defaultOption={'xixi'}
          />
      );
    });

    it('size should be input', () => {
       expect(wrapper.props().style).toEqual({width: 50});
       expect(wrapper.childAt(0).props().style).toInclude({height: 60});
    });

    it('defaultOption should be same with input', () => {
      const defaultOption = wrapper.childAt(0).childAt(0).props().children;
      expect(defaultOption).toEqual('xixi');
    });

    it('defaultOption should be initally within options', () => {
      const defaultOption = wrapper.childAt(0).childAt(0).props().children
      expect(options).toInclude(defaultOption);
    });

    it('defaultOption should be then moved out of options', ()=> {
      const optionsList = wrapper
      .find('li')
      .children()
      .forEach(node => expect(options).toExclude(node.children))
    });
  });

  describe('with onSelect func', () => {
    let wrapper;
    before(() => {
      wrapper = shallow(
        <MDDropDownMenu
          options={['xixi', 'haha']}
          defaultOption={'xixi'}
          onSelect
          />
      );
    });

  });

  describe('multiple menus', () => {
    let wrapper;
    before(() => {
      wrapper = mount(
        <div>
          <MDDropDownMenu
            options={['xixi', 'haha']}
            defaultOption={'xixi'}
          />
          <MDDropDownMenu
            options={['xixi', 'haha']}
            defaultOption={'xixi'}
          />
        </div>
      );
    });

    it('opening in one dropdownmenu should close others', () => {
      // because the styles are ignored. Don't know how to write this test
    });
  })

  describe('incomplete inputs', () => {

    let wrapper;
    before(() => {
      wrapper = shallow(
        <MDDropDownMenu
          options={['xixi', 'haha']}
        />
      );
    })

    it('should present empty string if not default option is provided', () => {
      const defaultOption = wrapper.childAt(0).childAt(0);
      expect(defaultOption.text()).toEqual('');
    })

  });

});
/* eslint-disable */


text:
GitHub html widget, include User Widget、Repo Widget and Activity Widget.

## Priview
### User Widget

## Repo Widget

## Activity Widget

## How to use
- User Widget

Copy and paste this code in your HTML body, replacing "data-username" with your GitHub username
```xml
<div class="github-widget" data-username="smuyyh"></div>
<script src="../js/github_user_widget_en.js"></script>
```

- Repo Widget

Copy and paste this code in your HTML body, replacing "data-repo" with your GitHub username/reponame
```xml
<script type="text/javascript" src="../js/jquery-1.7.1.min.js"></script>
<script type="text/javascript" src="../js/github_repo_widget_en.js"></script>
<div class="github-widget-repo" data-repo="smuyyh/SprintNBA" style="width:600px"></div>
```
or
```xml
<head>
    <link type="text/css" rel="stylesheet" href="../css/github_repo_widget_2.css"/>
</head>
<body>
    <div class="gitinfo" style="margin:15px 0; width:600px;"></div>

    <script src="../js/jquery-1.7.1.min.js"></script>
    <script type="text/javascript">var git_name ="/smuyyh/IncrementallyUpdate"</script>
    <script type="text/javascript" src="../js/github_repo_widget_2_en.js"></script>
</body>
```

- Activity Widget

Copy and paste link in your HTML head, and div/script in your HTML body, replacing "username" with your GitHub username
```xml
<head>
    <link href="../css/github_widget_activity.css" rel="stylesheet">
</head>

<body>
    <div id="widget-container" style="width:600px"></div>
    <script src="../js/jquery-1.7.1.min.js"></script>
    <script src="../js/github_widget_activity.js"></script>
    <script>
      $(function(){
        $('#widget-container').activity({
          username: 'smuyyh'
        });
      });
    </script>
</body>
```

## 为博客添加GitHub挂件(以CSDN博客为例)
管理博客 -> 博客栏目 -> 添加栏目
```xml
<div class="github-widget" data-username="smuyyh"></div>
<script type="text/javascript" src="https://rawgit.com/smuyyh/GitHubWidgets/master/js/github_user_widget_en.js"></script>

<!--js文件真实地址是以raw.githubusercontent.com开头,raw.githubusercontent.com在Response中设置了X-Content-Type-Options:nosniff ,
浏览器强制检查资源的MIME。解决方法就是将js链接中的raw.githubusercontent.com换成rawgit.com。  -->
```
![csdn](https://github.com/smuyyh/GitHubWidgets/blob/master/screenshot/csdn_widget_1.png?raw=true)

### 效果


text:
* [Matthew Woolhouse](woolhouse@mcmaster.ca) - Professor
* [Jotthi Bansal](bansalj@mcmaster.ca) - Lab instructor
* [Kurt](kurtbradd@gmail.com) - Developer
* [Michael](baronemda@gmail.com) - Developer
* [Michael Mallon](mallonm@mcmaster.ca) - IT Specialist

## Server info
* Server ip address: `130.113.103.46`
* Server host: `user_name@woolhouse-g.humanities.mcmaster.ca`

## How to use the Humanities Servers
1. Get access to the Humanities Server, ask [Dr. Woolhouse](woolhouse@mcmaster.ca) or [Jotthi](bansalj@mcmaster.ca).
2. Install VPN ([link](http://www.mcmaster.ca/uts/network/vpn/)) to access the server without being connected to McMaster's network.
3. ssh into the server. `ssh user_name@woolhouse-g.humanities.mcmaster.ca`.
---
# Redis Setup

---
# MySQL Setup
1. Download MySQL Community Edition (GPL) [link](https://dev.mysql.com/downloads/mysql/).
2. Change the temporary password:
Open the MySQL terminal.
```bash
mysql -u root -h 127.0.0.1 -p
```
For macs, there is no default MySQL config. Add a file to `usr/local/mysql/etc/my.cnf`. This will skip the default password.
```
skip-grant-tables
```

Change the temporary password:
```sql
ALTER USER 'root'@'localhost' IDENTIFIED BY 'new-password';
```

---

# Workflow (locally)

clone the repo.
get the credentials.
install mysql, redis.

### 1. MySQL Tables
Rows cannot be added/deleted by the crawler if the tables in the database are not created.
1. run `rsync -avz -e 'ssh -p 22' user_name@130.113.103.46:~/grail-dump.sql.gz ~/local_directory`.
    * This will download a copy of the sql data in the database currently onto your
    local machine.
2. run `mysql -u username -p database_name < file.sql`.
    * In the directory that you downloaded the data into your local machine, this will
    populate your local database with the data and populate the database with the tables and columns.

### 2. Getting the Grails Crawler to crawl
To populate the job queue and start the crawler
1. run `npm run development:master`
    * This initializes the dashboard and job queue.
2. go to dashboard --> [link](http://localhost:3001/)
    * NTS: port listed in confs
3. run `npm run seed:musicbrainz:track`
    * This loads the queue with jobs taken from the seed files (tsv).
4. run `npm run development:worker`
    * This plucks the jobs from the job queue and processes the jobs.
    * This also inserts into the database.

### 3. Reseting the Job Queue.
To test previous crawls you will or to reset the job queue.
1. run `redis-cli`
    * The jobs are stored in a redis database so you will need to start the redis
    command prompt.
2. run `flushall`
    * This will clear the redis database and delete all the queued jobs.


text:
/*
 * The main class responsible for inititaing the simulation executive, setting constants and tracking
 * the different states and properties of the cell population.
 */

import java.io.*;
import java.lang.Math.*;
import java.util.*;

public class CellProliferation
{
    /*
     * Global variables
     */
    private static int current_timepoint = 0; // Track the current time in this simulation, initialise at 0.
	private static int newest_generation = -1; // Keep track of the most recent generation of cells
	private static int id_of_last_created_cell = -1; // The cell ID of the last cell that was created. Tracked to set the ID of the next.
    private static int haploid_number; // Used to determine the size of the first dimension in the temp_genome_data array
    private static final int FEMALE = 1, MALE = 2, STRAND_LABELLED = 1, STRAND_UNLABELLED = 0;
    private static final boolean CAN_DIVIDE = true, CANT_DIVIDE = false;
    private static List<String>genome_data = new ArrayList<String>();

    /******************************************************
                  PART ONE : MAIN METHOD
    *******************************************************/
    public static void main(String [ ] args)
	{
		try
		{
			//Parse command line arguments
            String organism = null; //The target organism for the simulation, determines the genome data that will be parsed
            if(args[0].equals("Hum"))
                organism = "Homo sapiens";
            else if(args[0].equals("Mou"))
                organism = "Mus musculus";
            else if(args[0].equals("Test"))
                organism = "Test test";
            else
                printString("Please check and provide a valid organism name as the first input argument!");

            int sex = 0;
            if(args[1].equals("F"))
            sex = FEMALE;
            else if(args[1].equals("M"))
                sex = MALE;
            else
                printString("Please check that you provided 'F' or 'M' for gender!");

            final int INITIAL_POPULATION_SIZE = Integer.parseInt(args[2]);
            final int SIM_DURATION = Integer.parseInt(args[3]);
            final int TIME_INTERVAL = 24;//Integer.parseInt(args[4]);

            /******************************************************
             * Read the genome_data file to obtain data on the size
             * of each chromosome. Store this data in a String list.
             * Each line stores the integer sizes of each chromosome
             * pair, e.g for an organism of haploid# = 3;
             *  chr1 133797422,133797422
             *  chr2 242508799,242508799
             *  XY   198450956,130786757  <==The last line will have
             *                               two different values for
             *                               males (XY instead of XX)
             *
             */
            File genome_data_file = new File ("Genome_data.txt");
            genome_data = importGenomeData(genome_data_file, organism, sex);

            //printString(Integer.toString(genome_data.size()));
            //for(Iterator<String> i = genome_data.iterator(); i.hasNext();)
            //{
                //String item = i.next();
                //System.out.println(item);
            //}
            /******************************************************/

            List<Cell> cell_population = initiatePopulation(INITIAL_POPULATION_SIZE); //Initialise a population to be used at the start of the simulation

            //Run the simulation executive, providing the duration to run the simulation for, the time intervals at which events are evaluated and the initial cell population to perform the simulation of proliferation on
            cell_population = runSimulationExecutive(SIM_DURATION, TIME_INTERVAL, cell_population);
            //printLabelDistribOfPopulation(cell_population);
            generateOutput(cell_population, genome_data);

        }
		catch (NumberFormatException|IOException error)
		{
			//int missing_argument = Integer.parseInt(error.getMessage()) + 1;
			//print("Argument number " + missing_argument + " missing! Enter the correct number of arguments."); // Print error message on console if there are missing arguments
			printString("Oops! Something is wrong with the input values you provided. Check that you have entered the correct number, and types of arguments. Error type => " + error.getMessage());
            //Catch null pointer exceptions!!!
		}// try-catch

		//****************************************
		//1. Set a max time to run simulation
		//2. Set time intervals
		//3. Vars for fraction_dividing_cells, rate_cell_death, doubling_time/division_rate
		//4. Don't use a static variable for current_timepoint. Provide this value each time you deal with a cell, i.e in the for loop
		//5. cell_cycle_duration
	    //6. cell_cycle_frequency

		//***Maybe store all generations in single rows/columns of a two dimensional array?

	} // Method main

    /*******************************************************
                  PART TWO : OUTPUT AND ANALYSIS
     *******************************************************/

    /*
     *
     */
    private static void generateOutput(List<Cell> population, List<String>genome_data)
    {
        String newLine = System.getProperty("line.separator");
        printString("===================" + newLine + "GENERATE OUTPUT" + newLine + "===================");
        int generation = -1;
        int[][] chromosome_sizes = new int[haploid_number][2]; //The size of each chromosome (deploid) stored in a 2D array
        int diploid_genome_size = 0; //The sum of all chromosome sizes

        //Produce array of chromosome sizes, garbage clean genome_data
        //For each element in genome_data, split by comma and place into two elements of chromosome sizes array
        int current_chromosome = 0;
        for(Iterator<String> i = genome_data.iterator(); i.hasNext();current_chromosome++)
        {
            String item = i.next();
            String[] homologous_pair_sizes = item.split(",");
            chromosome_sizes[current_chromosome][0] = Integer.parseInt(homologous_pair_sizes[0]);
            chromosome_sizes[current_chromosome][1] = Integer.parseInt(homologous_pair_sizes[1]);
            diploid_genome_size += chromosome_sizes[current_chromosome][0];
            diploid_genome_size += chromosome_sizes[current_chromosome][1];
            System.out.println(item);
        }

        //Print chromosome sizes array
        /*for(int chromosome_count = 0; chromosome_count < chromosome_sizes.length; chromosome_count++)
        {
            for(int homologous_pair_count= 0; homologous_pair_count < chromosome_sizes[chromosome_count].length; homologous_pair_count++)
            {
                printString(Integer.toString(chromosome_sizes[chromosome_count][homologous_pair_count]));
            }
        }*/

        printString("Size of diploid genome in base pairs = " + Integer.toString(diploid_genome_size));
        genome_data = null; // Garbage collection

        //new  Cell(cell_id, cell_generation, last_div, CAN_DIVIDE, diploid_genome));
        //For each cell in population 1)Track each generation and push cells to 2D array
        //2)Track % new DNA of each cell and total % new DNA of each generation

        double [] generation_label_percentage = new double[newest_generation+1];
        int [] cells_in_each_generation = new int[newest_generation+1];
        for (int this_generation : cells_in_each_generation)
        {
            this_generation = 0;
        }
        //Gather information from each cell

        //Go through each cell and obtain its generation number and update the corresponding % new DNA
        for(int cell_count = 0; cell_count < population.size(); cell_count++)
        {
            Cell current_cell = population.get(cell_count);
            int [][][] this_cells_genome = current_cell.getGenome();
            int generation_of_this_cell = current_cell.getGeneration();
            double cell_percentage_labelled = 0.0;

            // For each chromosome
            for(int chromosome_count = 0; chromosome_count < this_cells_genome.length; chromosome_count++)
            {
                double chromo_percentage_labelled = 0;// Label status of each chromosome
                for(int homologous_pair_count= 0; homologous_pair_count < this_cells_genome[chromosome_count].length; homologous_pair_count++)
                {
                    int homolog_size = chromosome_sizes[chromosome_count][homologous_pair_count]; //Chromosome size in base pairs
                    double chromosome_proportion_of_genome = (double)homolog_size/diploid_genome_size; // The size of the chromosome relative to the diploid genome
                    double strand_percentage_labelled = 0;
                    for(int dna_strand_count = 0; dna_strand_count < this_cells_genome[chromosome_count][homologous_pair_count].length; dna_strand_count++)
                    {
                        int label_status = this_cells_genome[chromosome_count][homologous_pair_count][dna_strand_count];
                        switch (label_status)
                        {
                            case STRAND_UNLABELLED:
                                //double percentage_calc =
                                //strand_percentage_labelled =

                            break;
                            case STRAND_LABELLED:
                                strand_percentage_labelled = 1.0;
                                chromo_percentage_labelled = (chromo_percentage_labelled + strand_percentage_labelled) / 2;
                                strand_percentage_labelled = 0.0;
                                //printString(Double.toString(chromo_percentage_labelled));

                            break;
                        }
                    }
                    cell_percentage_labelled += chromo_percentage_labelled * chromosome_proportion_of_genome;
                }
            }// For each chromosome
            generation_label_percentage[generation_of_this_cell] += (generation_label_percentage[generation_of_this_cell] + cell_percentage_labelled) / 2;

            int temp_number_cells = cells_in_each_generation[generation_of_this_cell] + 1;
            cells_in_each_generation[generation_of_this_cell] = temp_number_cells;
            //printString(generation_of_this_cell + "   " + cell_percentage_labelled);

            //population_by_generations.add(new  Cell(current_generation),null);
        }// for

        //Go through the population and sort cells into the 2D array by their generation number
        //for(int current_cell = 0; current_cell < cells_in_each_generation.length; current_cell++)
        //{
           // printString(current_cell + "   " + cells_in_each_generation[current_cell]);

        //}// for

        for(int current_generation = 0; current_generation < generation_label_percentage.length; current_generation++)
        {
            printString("Generation: " + current_generation + "     % labelled: " + generation_label_percentage[current_generation]);

        }// for

        //printLabelDistribOfPopulation(population);

    }// generateOutput()

    /*
     *
     */
    private static void printLabelDistribOfCell(Cell cell)
    {
        int[][][] genome = cell.getGenome();

        for(int chromosome_count = 0; chromosome_count < genome.length; chromosome_count++)
        {
            for(int homologous_pair_count= 0; homologous_pair_count < genome[chromosome_count].length; homologous_pair_count++)
            {
                for(int dna_strand_count = 0; dna_strand_count < genome[chromosome_count][homologous_pair_count].length; dna_strand_count++)
                {
                    printString("Chromosome " + Integer.toString(chromosome_count+1) + "; Homologous Pair " + Integer.toString(homologous_pair_count+1) + "; Strand " + Integer.  toString(dna_strand_count+1) + " - Label status = " + Integer.toString(genome[chromosome_count][homologous_pair_count][dna_strand_count]));
                }
            }
        }
    }// printLabelDistribOfPopulation

    /*
     *
     */
    private static void printLabelDistribOfPopulation(List<Cell> population)
    {
        for(int cell_count = 0; cell_count < population.size(); cell_count++)
        {
            printString(cell_count + " "+ population.get(cell_count).toString());

            int[][][] blank_genome = new int[haploid_number][2][2];

            for(int chromosome_count = 0; chromosome_count < blank_genome.length; chromosome_count++)
            {
                for(int homologous_pair_count= 0; homologous_pair_count < blank_genome[chromosome_count].length; homologous_pair_count++)
                {
                    for(int dna_strand_count = 0; dna_strand_count < blank_genome[chromosome_count][homologous_pair_count].length; dna_strand_count++)
                    {
                        printString("Chromosome " + Integer.toString(chromosome_count+1) + "; Homologous Pair " + Integer.toString(homologous_pair_count+1) + "; Strand " + Integer.  toString(dna_strand_count+1) + " - Label status = " + Integer.toString(population.get(cell_count).getGenome()[chromosome_count][homologous_pair_count][dna_strand_count]));
                    }
                }
            }
        }// for population
    }// printLabelDistribOfPopulation

    /*
     * Method to print a string passed to it
     */
    public static void printString(String print_this)
    {
        System.out.println(print_this);
    }// print

    /*******************************************************
             PART THREE : MAIN METHOD SUB ROUTINES
     *******************************************************/

	/*
	 *
	 */
	private static List<Cell> runSimulationExecutive(int sim_duration, int simulation_time_interval, List<Cell> cell_population)
	{
		int population_size = cell_population.size();
        int[][][] blank_genome = new int[haploid_number][2][2]; // A blank diploid genome - The karyotype of the cell, 3 dimensional array to store discrete values for each  chromosome -> each homologous pair of chromosomes -> 2 complementary DNA strands'

        //Progress through time at selected intervals for a specified duration
		for(int current_time = 0; current_time < sim_duration; current_time += simulation_time_interval)
        {
            printString(current_time + " " + population_size);
            //Perform division of all cells that can divide as determined by a random number generator and the set division threshhold
            //As new cells are being added to the list, only go through the cells present in the population before new cells were added in this round i.e use the previous population size as max number of iterations.
            for(int current_element = 0; current_element < population_size; current_element++)
            {
                Cell current_cell = cell_population.get(current_element);
                boolean current_cell_can_divide = current_cell.getDivisionStatus();
                if(current_cell_can_divide)
                {

                    //Produce a random number, R, between ***********????!!!!!!!!!
                    double between_zero_and_one = randomDouble();
                    if(between_zero_and_one < 0.2) //The cell can divide
                    {
                        //Remove one cell from the current generation and add two to the next
                        //by changing the generation of the original cell to current_gen + 1 and
                        //creating a new cell object also in generation current_gen + 1

                        final int daughter_cell_one = current_element; //The original cell will become daughter cell one

                        // Change the orginal cell to daughter cell 1 by increasing its generation value by 1, from its current generation
                        //printString("Generation of parent cell = " + daughter_cell_one.getGeneration());
                        //printString("Cell ID of parent cell = " + daughter_cell_one.getId());
                        int next_generation = cell_population.get(daughter_cell_one).getGeneration() + 1;
                        cell_population.get(daughter_cell_one).setGeneration(next_generation);
                        //This is now a new cell, change its ID to a new unique one???????

                        //Create a new cell object which will become daughter cell 2, with a blank diploid genome, of same generation as the newly created daughter cell 1
                        cell_population.add(new  Cell(id_of_last_created_cell + 1, next_generation, -1, CAN_DIVIDE, newEmptyDeploidGenome()));
                        id_of_last_created_cell++;
                        printString("Population size after division = " + cell_population.size());
                        final int daughter_cell_two = (cell_population.size() - 1); //Create and set daughter cell 2 to the newly created cell object
                        printLabelDistribOfCell(cell_population.get(daughter_cell_two));
                        /*********************************************************/
                        // Track the latest generation of cells.
                        if(cell_population.get(daughter_cell_one).getGeneration() > newest_generation)
                        {newest_generation++;}
                        /*********************************************************/

                        //CREATE AN EMPTY GENOME
                        int[][][] empty_diploid_genome = newEmptyDeploidGenome();

                        int[][][] temp_genome_d1 = cell_population.get(daughter_cell_one).getGenome(), temp_genome_d2 = empty_diploid_genome;

                        printString("MITOTIC EVENT  Index of daughter cell two --->" + (cell_population.size()-1));

                        //printString(Integer.toString(current_element));
                        printString("Daughter cell 1 --->" + cell_population.get(current_element).toString());
                        printLabelDistribOfCell(cell_population.get(current_element));
                        printString("Daughter cell 2 --->" + cell_population.get(cell_population.size() - 1).toString());
                        printLabelDistribOfCell(cell_population.get(cell_population.size() - 1));
                    }// if(between_zeroANDone >= 0.5)

                    else //Cell doesn't divided
                    {
                        printString("Didn't divide --->" + current_cell.toString());
                        printLabelDistribOfCell(cell_population.get(current_element));

                    }

                } // if the cell can divide

                //printString(Integer.toString(cell_population.get(current_element).getGeneration()));

            } // for all cells in the main population
            population_size = cell_population.size(); // Update the population size after the round of division
            printString(current_time + " " + population_size);
        }// for
        printString("Latest generation = " + (newest_generation));
        printLabelDistribOfPopulation(cell_population);

        return cell_population;
	}// runSimulationExecutive

    /*
     *
     */
    private static double randomDouble()
    {
        Random rand = new Random();
        return rand.nextDouble();
    }// randomDouble

     /*
      *
      */
    private static List<String> importGenomeData(File genome_text_file, String target_organism, int sex) throws IOException
    {

        List<String> temp_genome_data = new ArrayList<String>(); // The genome data list that contains the sizes of each chromosome on a line. Format
        //int haploid_number; // Used to determine the size of the first dimension in the temp_genome_data array
        boolean found_target_organism = false; // Used to determine what action to take when a new header line in the file is found; close if true, keep reading if false
        boolean end_of_genome = false; // True when the Y chromosome has been dealt with, for this to work the file being imported has to have the Y chr line after not before the X chr line

        // Construct BufferedReader from FileReader; search for header line of target organism and
        // obtain the haploid number then create a three dimensional array(size of the first dimension
        // equals the haploid number; size of second dimension equals two) i.e two chromosomes to form deploid organism.
        // At this point, the next lines correspond to the size of each chromosome so populate the newly created array
        // with this information. Stop reading when no more new lines or when a new header line is found
        BufferedReader genome_file_reader = new BufferedReader(new FileReader(genome_text_file));

        String line = null;
        StringBuilder organism_name;
        while ((line = genome_file_reader.readLine()) != null)
        {
            String[] split_line = line.split(" ");

            if(split_line[0].equals(">")) // If this is a first header line
            {
                organism_name = new StringBuilder().append(split_line[1]).append(" ").append(split_line[2]); // Recreate the genus and species of the organism from the strings that were separated during the splitting of the line
                if(organism_name.toString().equals(target_organism)) // If this line refers to the organism of interest
                {
                    found_target_organism = true;
                    haploid_number = Integer.parseInt(split_line[4]); // Get the haploid number stored in the header line
                }
                else
                {
                    found_target_organism = false;
                    continue; //This is a header line but it is not the organism of interest
                }
            }
            else if(found_target_organism && !end_of_genome)// This is not a header line so we evaluate whether we want to import this line
            {
                //boolean autosome = true;
                switch(sex)
                {
                    case 1://Female
                    {
                        if(split_line[0].equals("chrX"))
                        {
                            temp_genome_data.add(split_line[1] + "," + split_line[1]);
                        }
                        else if(split_line[0].equals("chrY"))
                        {
                            end_of_genome = true;
                        }// Ignore the Y chromosome
                        else
                            temp_genome_data.add(split_line[1] + "," + split_line[1]);// The current line is an autosome
                    }break;
                    case 2://Male
                    {
                        if(split_line[0].equals("chrX"))
                        {
                            temp_genome_data.add(split_line[1] + ",");
                        }
                        else if(split_line[0].equals("chrY"))
                        {
                            String temp = temp_genome_data.get(temp_genome_data.size() - 1); // Store the value already there
                            temp_genome_data.remove(temp_genome_data.size()-1);

                            temp = temp + split_line[1];
                            temp_genome_data.add(temp);

                            end_of_genome = true;
                        }
                        else
                            temp_genome_data.add(split_line[1] + "," + split_line[1]);// The current line is an autosome
                    }break;
                }
            }
        }// while ((line = genome_file_reader.readLine()) != null)
        genome_file_reader.close();
        return temp_genome_data;
    }// importGenomeData

    /*
     * Creates and returns an array list of the initial population of cells.
     * The total number of cells in the population is determined by the integer 'population_size'
     */
    private static List<Cell> initiatePopulation(int required_population_size)
    {
        List<Cell> population = new ArrayList<Cell>(); //Define an arraylist to hold the initial population of cells
        int[][][] diploid_genome = newEmptyDeploidGenome();
        int cell_generation = newest_generation + 1, last_div = -1;

        //Set the label status of all DNA strands in the genome to unlabelled
        for(int chromosome_count = 0; chromosome_count < diploid_genome.length; chromosome_count++)
        {
            for(int homologous_pair_count= 0; homologous_pair_count < diploid_genome[chromosome_count].length; homologous_pair_count++)
            {
                for(int dna_strand_count = 0; dna_strand_count < diploid_genome[chromosome_count][homologous_pair_count].length; dna_strand_count++)
                {
                    diploid_genome[chromosome_count][homologous_pair_count][dna_strand_count] = STRAND_UNLABELLED; //Set each DNA strand to unlabelled
                }
            }
        }

        // !****!Create the starting population of cells, all as generation 0!****!
        for (int counter = 0; counter < required_population_size; counter++)
        {
            int cell_id = counter;
            population.add(new  Cell(cell_id, cell_generation, last_div, CAN_DIVIDE, diploid_genome)); // Create a new Cell object with the following values.
            id_of_last_created_cell = cell_id; // Track the id of the last created cell
        }// for
        newest_generation++;
        return population;
    }// initiate_first_population()

    /*
     * Creates and returns an empty three dimensional array to store a deploid genome
     */
    private static int[][][] newEmptyDeploidGenome()
    {
        int[][][] diploid_genome = new int[haploid_number][2][2]; // The karyotype of the cell, 3 dimensional array to store discrete values for each  chromosome -> each homologous pair of chromosomes -> 2 complementary DNA strands
        return diploid_genome;
    }// newEmptyDeploidGenome()

	/*
	 * Method to access the current timepoint in the simulation executive
	 */
	public int getCurrentTimepoint()
	{
		return current_timepoint;
	}// getCurrentTimepoint

}// Class Mitosis


text:
const express = require('express');
const expect = require('unexpected')
  .clone()
  .use(require('unexpected-express'));
const expressLegacyCsp = require('../');

let userAgentString;
let inputHeaderName;
let expectedOutputHeaderName;
beforeEach(() => {
  userAgentString = undefined;
  inputHeaderName = 'Content-Security-Policy';
  expectedOutputHeaderName = 'Content-Security-Policy';
});

expect.addAssertion(
  '<string|array> to come out as <string|array|undefined>',
  (expect, subject, value) => {
    return expect(
      express()
        .use(expressLegacyCsp())
        .use((req, res, next) => {
          if (Array.isArray(subject)) {
            subject.forEach(headerValue =>
              res.append('Content-Security-Policy', headerValue)
            );
          } else {
            res.setHeader(inputHeaderName, subject);
          }
          res.status(200).end();
        }),
      'to yield exchange',
      {
        request: { headers: { 'User-Agent': userAgentString } },
        response: { headers: { [expectedOutputHeaderName]: value } }
      }
    );
  }
);

expect.addAssertion('<string|array> to be left intact', (expect, subject) =>
  expect(subject, 'to come out as', subject)
);

describe('with an empty policy', function() {
  // Safari 7
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A';
  });

  it('should output an empty policy', function() {
    return expect('', 'to be left intact');
  });
});

describe('with a browser that caniuse-db has data about in a version that is older than all the explicitly mentioned ones', function() {
  // Chrome 1
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/525.19 (KHTML, like Gecko) Chrome/1.0.154.36 Safari/525.19';
  });

  it('should assume that CSP is not supported and strip the header', function() {
    return expect(
      'script-src somewhere.com/with/a/path',
      'to come out as',
      undefined
    );
  });
});

describe('with a policy that has a trailing semicolon', function() {
  // Safari 7
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A';
  });

  it('should remove the semicolon when reserializing', function() {
    return expect('foo;', 'to come out as', 'foo');
  });
});

describe('with a policy that has a leading semicolon', function() {
  // Safari 7
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A';
  });

  it('should remove the semicolon when reserializing', function() {
    return expect(';foo', 'to come out as', 'foo');
  });
});

describe('with multiple directives', function() {
  // Safari 7
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A';
  });

  it('should rejoin the directives with semicolon followed by a space', function() {
    return expect('foo;bar', 'to come out as', 'foo; bar');
  });
});

describe('with multiple CSP headers', function() {
  // Safari 7
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A';
  });

  it('should process all headers', function() {
    return expect(
      ['script-src somewhere.com/with/a/path', "script-src 'nonce-foo'"],
      'to come out as',
      ['script-src somewhere.com', "script-src 'unsafe-inline'"]
    );
  });
});

describe('with multiple comma-separated policies in a single header', function() {
  // Safari 7
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A';
  });

  it('should process each contained policy individually and reassemble them', function() {
    return expect(
      "script-src somewhere.com/with/a/path, script-src 'sha256-XeYlw2NVzOfB1UCIJqCyGr+0n7bA4fFslFpvKu84IAw='",
      'to come out as',
      "script-src somewhere.com, script-src 'unsafe-inline'"
    );
  });
});

describe('with a "report only" CSP header', function() {
  describe('in a browser that does not require the "base" header name to be changed', function() {
    // Safari 7
    beforeEach(() => {
      inputHeaderName = expectedOutputHeaderName =
        'Content-Security-Policy-Report-Only';
      userAgentString =
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A';
    });

    it('should process the header', function() {
      return expect(
        'script-src somewhere.com/with/a/path',
        'to come out as',
        'script-src somewhere.com'
      );
    });
  });

  describe('in a browser that does require the "base" header name to be changed', function() {
    // Safari 6
    beforeEach(() => {
      inputHeaderName = expectedOutputHeaderName =
        'Content-Security-Policy-Report-Only';
      expectedOutputHeaderName = 'X-Webkit-CSP-Report-Only';
      userAgentString =
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/536.26.17 (KHTML, like Gecko) Version/6.0.2 Safari/536.26.17';
    });

    it('should process the header', function() {
      return expect(
        'script-src somewhere.com/with/a/path',
        'to come out as',
        'script-src somewhere.com'
      );
    });
  });
});

describe('in Chrome 28 on Android 4.4.2', function() {
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Linux; Android 4.4.2: sv-se; SAMSUNG SM-C115 Build/KOT49H) AppleWebKit/537.36 (KHTML, like Gecko) Version/1.6 Chrome/28.0.1500.94 Mobile Safari/537.36';
  });

  it('should strip the Content-Security-Policy header', () => {
    return expect(
      "script-src somewhere.com/with/a/path 'strict-dynamic'",
      'to come out as',
      undefined
    );
  });
});

describe('in Safari 5', function() {
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_8; de-at) AppleWebKit/533.21.1 (KHTML, like Gecko) Version/5.0.5 Safari/533.21.1';
  });

  it('should remove the Content-Security-Policy header', () => {
    return expect(
      "script-src somewhere.com/with/a/path 'strict-dynamic'",
      'to come out as',
      undefined
    );
  });
});

describe('in Safari 6', function() {
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/536.26.17 (KHTML, like Gecko) Version/6.0.2 Safari/536.26.17';
    expectedOutputHeaderName = 'X-Webkit-CSP';
  });

  it('should downgrade to CSP 1 and switch to the X-Webkit-CSP header', () => {
    return expect(
      "script-src somewhere.com/with/a/path 'strict-dynamic'",
      'to come out as',
      "script-src somewhere.com 'unsafe-inline'"
    );
  });
});

describe('in Safari 7', function() {
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A';
  });

  it('should downgrade to CSP 1', () => {
    return expect(
      "script-src somewhere.com/with/a/path 'strict-dynamic'",
      'to come out as',
      "script-src somewhere.com 'unsafe-inline'"
    );
  });
});

describe('in Safari 8', function() {
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/600.7.12 (KHTML, like Gecko) Version/8.0.7 Safari/600.7.12';
  });

  it('should strip the path from a source expression without a scheme', () => {
    return expect(
      'script-src somewhere.com/with/a/path',
      'to come out as',
      'script-src somewhere.com'
    );
  });

  it('should strip the path from a source expression with a scheme', () => {
    return expect(
      'script-src https://somewhere.com/with/a/path',
      'to come out as',
      'script-src https://somewhere.com'
    );
  });

  it('should dedupe after stripping the path', () => {
    return expect(
      'script-src somewhere.com/with/a/path somewhere.com/with/another/path',
      'to come out as',
      'script-src somewhere.com'
    );
  });
});

describe('in Safari 10', function() {
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_1) AppleWebKit/602.2.14 (KHTML, like Gecko) Version/10.0.1 Safari/602.2.14';
  });

  it('should downgrade to CSP 2', () => {
    return expect(
      "script-src somewhere.com/with/a/path 'strict-dynamic'",
      'to come out as',
      "script-src somewhere.com/with/a/path 'unsafe-inline'"
    );
  });
});

describe('in Mobile Safari 9.0 (iOS 9)', function() {
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (iPad; CPU OS 9_3_5 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13G36 Safari/601.1';
  });

  it('should downgrade to CSP 1', () => {
    return expect(
      "script-src somewhere.com/with/a/path 'strict-dynamic'",
      'to come out as',
      "script-src somewhere.com 'unsafe-inline'"
    );
  });
});

describe('in Firefox 51', function() {
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:51.0) Gecko/20100101 Firefox/51.0';
  });

  it('should not have CSP level 2 constructs downgraded, even though caniusedb says "a #7"', function() {
    return expect('script-src somewhere.com/with/a/path', 'to be left intact');
  });
});

describe('in Edge 13', function() {
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2486.0 Safari/537.36 Edge/13.10586';
  });

  it('should have CSP level 2 constructs downgraded', function() {
    return expect(
      "script-src somewhere.com/with/a/path 'sha256-XeYlw2NVzOfB1UCIJqCyGr+0n7bA4fFslFpvKu84IAw='",
      'to come out as',
      "script-src somewhere.com 'unsafe-inline'"
    );
  });
});

describe('in Edge 76', function() {
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (Windows NT 10.0; ARM; RM-1141) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36 Edge/76.14977';
  });

  it('should leave CSP level 2 constructs intact', function() {
    return expect(
      "script-src somewhere.com/with/a/path 'sha256-XeYlw2NVzOfB1UCIJqCyGr+0n7bA4fFslFpvKu84IAw='",
      'to be left intact'
    );
  });
});

describe('in IE10', function() {
  beforeEach(() => {
    userAgentString =
      'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/6.0)';
    expectedOutputHeaderName = 'X-Content-Security-Policy';
  });

  it('should strip the path from a source expression without a scheme', () => {
    return expect(
      'script-src somewhere.com/with/a/path',
      'to come out as',
      'script-src somewhere.com'
    );
  });
});

describe('in a CSP2 compliant browser', () => {
  beforeEach(() => {
    // Chrome 55
    userAgentString =
      'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36';
  });

  it('should remove CSP3 constructs', () => {
    return expect(
      "script-src 'unsafe-hashed-attributes'",
      'to come out as',
      "script-src 'unsafe-inline'"
    );
  });

  it('should keep CSP2 constructs', () => {
    return expect('script-src somewhere.com/with/a/path', 'to be left intact');
  });
});

describe('in a CSP1 compliant browser', () => {
  beforeEach(() => {
    // Chrome 14
    userAgentString =
      'Mozilla/5.0 (Windows NT 6.0; WOW64) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.2 Safari/535.1';
  });

  it('should remove CSP3 and CSP2 constructs', () => {
    return expect(
      "script-src 'unsafe-hashed-attributes' somewhere.com/with/a/path somewhere.com/with/another/path",
      'to come out as',
      "script-src somewhere.com 'unsafe-inline'"
    );
  });
});

describe('in a browser that does not support CSP', function() {
  beforeEach(() => {
    // Chrome 13
    userAgentString =
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_3) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.220 Safari/535.1';
  });

  it('should remove CSP3 and CSP2 constructs', () => {
    return expect(
      "script-src 'unsafe-hashed-attributes' somewhere.com/with/a/path somewhere.com/with/another/path",
      'to come out as',
      undefined
    );
  });
});

describe('in an unknown browser', function() {
  beforeEach(() => {
    userAgentString = 'Sunshine, lollipops and rainbows';
  });

  it('should preserve the CSP as-is', function() {
    return expect("script-src 'strict-dynamic'", 'to be left intact');
  });
});

it('should not crash when the parsed version number is not accepted by the semver module due to leading zeroes', function() {
  userAgentString =
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_3) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/999.01.782.220 Safari/535.1';
  return expect(
    "script-src 'strict-dynamic'",
    'to come out as',
    "script-src 'unsafe-inline'"
  );
});

describe('with CSP2 directives', function() {
  describe('in CSP2 capable browsers', function() {
    it('should keep the directives in Safari 10.1', function() {
      userAgentString =
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/603.3.8 (KHTML, like Gecko) Version/10.1.2 Safari/603.3.8';
      return expect(
        "frame-ancestors 'none'; child-src 'self'; script-src 'self'",
        'to be left intact'
      );
    });
  });

  describe('in CSP1 capable browsers', function() {
    it('should drop the directives in Safari 9.1', function() {
      userAgentString =
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/601.7.8 (KHTML, like Gecko) Version/9.1.3 Safari/601.7.8';
      return expect(
        "frame-ancestors 'none'; child-src 'self'; script-src 'self'",
        'to come out as',
        "script-src 'self'"
      );
    });
  });

  describe('with CSP3 directives', function() {
    describe('in CSP2 capable browsers', function() {
      it('should drop the directives in Safari 10.1', function() {
        userAgentString =
          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/603.3.8 (KHTML, like Gecko) Version/10.1.2 Safari/603.3.8';
        return expect(
          "manifest-src 'self'; worker-src; report-to https://example.com; script-src 'self'",
          'to come out as',
          "script-src 'self'"
        );
      });
    });
  });
});


text:
<!doctype html>

    <meta charset="utf-8">

    <title>JavaScript Promise</title>

    <meta name="description" content="A framework for easily creating beautiful presentations using HTML">
    <meta name="author" content="Werner Badenhorst">

    <meta name="apple-mobile-web-app-capable" content="yes" />
    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />

    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, minimal-ui">

    <link rel="stylesheet" href="css/reveal.css">

    <link rel="stylesheet" href="css/theme/sky.css" id="theme">

    <link rel="stylesheet" href="plugin/highlight/css/solarized_dark.css">