*NEED BY 10:59!!

Ogonquit Enterprises prepares annual financial statements and adjusts its accounts only at the end of the year. The following information is available for the year ended December 31, 2016:

Required:

1. Carolina Consulting Company has a defined benefit pension plan. The following pension-related data were available for the current calendar year:

1. Calculate the 2016 pension expense.     

2. Prepare the 2016 journal entries to record pension expense

3. Prepare the 2016 journal entries to record funding.

4.Prepare any journal entries to record any 2016 gains or losses

5. Fill in the following spreadsheet :

Wright Development purchases, develops, and sells commercial building sites. As the sites are sold, they are cleared at an average cost of $2,500 per site. Storm drains and driveways are also installed at an average cost of $5,500 per site. Selling costs are 10 percent of sales price. Administrative costs are $420,000 per year. During 2016, the company bought 1,000 acres of land for $5,000,000 and divided it into 200 sites of equal size. The average selling price per site was $85,000 during 2016 when 50 sites were sold. During 2017, the company purchased and developed another 1,000 acres, divided into 200 sites. The purchase price was again $5,000,000. Sales totaled 300 sites in 2017 at an average price of $85,000.

Required a. Prepare 2016 and 2017 functional income statements using absorption costing.

Use a negative sign only to indicate a net loss for income. Otherwise, do not use negative signs with your answers.

b. Prepare 2016 and 2017 contribution income statements using variable costing.

Use a negative sign only to indicate a net loss for income. Otherwise, do not use negative signs with your answers.

I need to implement incrementalInserstionSort im stuck on that part

import java.util.*;

/**
 * This class represents chains of linked nodes that
 * can be sorted by a Shell sort.
 *
 * @author Charles Hoot
 * @author Frank M. Carrano
 *         Modified by atb
 * @author YOUR NAME
 * @version 9/29/2020
 */
public class ChainSort>
{
    private Node firstNode; // reference to first node

    public ChainSort()
    {
        this.firstNode = null;
    }

    public void display()
    {
        Node currentNode = this.firstNode;
        while (currentNode != null)
        {
            System.out.print(currentNode.data + " ");
            currentNode = currentNode.next;
        }
        System.out.println();
    } // end display

    public boolean isEmpty()
    {
       return this.firstNode == null;
    } // end isEmpty

    public void addToBeginning(T newEntry)
    {
        Node newNode = new Node<>(newEntry);
        newNode.next = this.firstNode;
        this.firstNode = newNode;
    } // end addToBeginning

    public void shellSort(int chainSize)
    {
        //TODO Project3

        for (int space = chainSize / 2; space > 0; space = space / 2)
        {
            //     create sub-chains:
            //          set previousNode to the first node in the chain
            //          set currentNode to the first node in the chain
            //          with a for loop traverse nodes space times using currentNode
            //            to find the second node of the first sub-chain
            //
            //          with a while loop set up backward links for all sub-chains:
            //              set currentNode's previous pointer to the previousNode
            //              set previousNode to its next node and do the same with the currentNode
            Node currentNode = this.firstNode;
            Node previousNode = this.firstNode;
            for (int index = 0; index < space; index++)
            {
                currentNode = currentNode.next;
            }


            while (currentNode != null)
            {
                previousNode = previousNode.next;
                currentNode = currentNode.next;
            }



            System.out.println("\n\u001B[35m\u001B[1m----->Before partial sort with space " + space + " :\u001B[0m");
            display();
            // sort all the sub-chains:
            incrementalInsertionSort(space);
            System.out.println("\u001B[35m\u001B[1m----->After partial sort done with space " + space + " :\u001B[0m");
            display();
        }
    } // end shellSort

    /**
     * Task: Sorts equally spaced elements of a linked chain into
     * ascending order. Sub-chains created with a use of previous.
     *
     * @param space the space between the nodes of the
     *              elements to sort
     */
    private void incrementalInsertionSort( int space)
    {
        //TODO Project3
        // when sorting do not change pointers - simply swap the data if needed


    } // end incrementalInsertionSort


    private class Node
    {
        private S data;
        private Node next;
        private Node previous; // ADDED for linking backwards for shell sort

        private Node(S dataPortion)
        {
            this.data = dataPortion;
            this.next = null;
            this.previous = null;
        }
    } // end Node

    // ************ TEST DRIVER *****************

    public static void main(String args[])
    {
        System.out.println("What size chain should be used?");
        int chainSize = getInt("   It should be an integer value greater than or equal to 1.");

        System.out.println("What seed value should be used?");
        int seed = getInt("   It should be an integer value greater than or equal to 1.");
        Random generator = new Random(seed);
        ChainSort myChain = new ChainSort<>();

        for (int i = 0; i < chainSize; i++)
            myChain.addToBeginning(generator.nextInt(100));

        System.out.print("\nOriginal Chain Content: ");
        myChain.display();
        myChain.shellSort(chainSize);
        System.out.print("\nSorted Chain Content: ");
        myChain.display();
    }


    /**
     * Get an integer value
     *
     * @param rangePrompt String representing a message used to ask the user for input
     * @return an integer
     */
    private static int getInt(String rangePrompt)
    {
        Scanner input;
        int result = 10;        //default value is 10
        try
        {
            input = new Scanner(System.in);
            System.out.println(rangePrompt);
            result = input.nextInt();

        } catch (NumberFormatException e)
        {
            System.out.println("Could not convert input to an integer");
            System.out.println(e.getMessage());
            System.out.println("Will use 10 as the default value");
        } catch (Exception e)
        {
            System.out.println("There was an error with System.in");
            System.out.println(e.getMessage());
            System.out.println("Will use 10 as the default value");
        }
        return result;
    }
} // end ChainSort

Blue Company began operations on January 2, 2016. It employs 10 individuals who work 8-hour days and are paid hourly. Each employee earns 12 paid vacation days and 7 paid sick days annually. Vacation days may be taken after January 15 of the year following the year in which they are earned. Sick days may be taken as soon as they are earned; unused sick days accumulate. Additional information is as follows.

Blue Company has chosen not to accrue paid sick leave until used, and has chosen to accrue vacation time at expected future rates of pay without discounting. The company used the following projected rates to accrue vacation time.

Prepare journal entries to record transactions related to compensated absences during 2016 and 2017

Compute the amounts of any liability for compensated absences that should be reported on the balance sheet at December 31, 2016 and 2017.

Homestead Oil Corp. was incorporated on January 1, 2016, and issued the following stock for cash:

700,000 shares of no-par common stock were authorized; 150,000 shares were issued on January 1, 2016, at $18.00 per share.

250,000 shares of $110 par value, 8.00% cumulative, preferred stock were authorized, and 71,000 shares were issued on January 1, 2016, at $140 per share.

Net income for the years ended December 31, 2016 and 2017, was $1,450,000 and $2,490,000, respectively.

No dividends were declared or paid during 2016. However, on December 28, 2017, the board of directors of Homestead declared dividends of $1,600,000, payable on February 12, 2018, to holders of record as of January 19, 2018.

Prepare the journal entries to record each of the below transactions. (If no entry is required for a transaction/event, select "No journal entry required" in the first account field.)

The issuance of common stock and preferred stock on January 1, 2016.

The declaration of dividends on December 28, 2017.

The payment of dividends on February 12, 2018.

Note: Enter debits before credits.

b. Of the total amount of dividends declared during 2017, how much will be received by preferred shareholders?

The following are the financial statements of Rigolo Inc.

Balance sheet

Statement of income

Rigolo Inc, has paid $10,000 to its preferred shareholders in 2016

Tasks: (i) Compute the ROA

          (ii) Compute the ROCE

          (iii) Compute the Account Receivable Turnover

          (iv) Compute the Inventory Turnover

          (v) Compute the Basic EPS

          (vi) Compute the diluted EPS

Note: Provide for each ratio: the financial meaning and the formula used for its computation. Do not just put numbers.

أHow can we discuss Magnetic Fields of Coils lab experiment ?

What do you know about experiment design? And mention the types.