anchor.diff:    let app =
       choose
         [ GET >=> choose
  -          [ path "/ingredients" >=> 
  -              request (fun _ -> referenceData state |> ingredients |> json |> OK)
  -            path "/blueprints"  >=> 
  -              request (fun _ -> referenceData state |> blueprints |> json |> OK)
  -            path "/commanders"  >=> 
  -              request (fun _ -> state.Invoke().Keys |> json |> OK)
  +          [ pathScan "/ingredients%s" (fun (format) -> 
  +              (request(fun request ->
  +                cmdr {
  +                  let! f = FormatExtractor(format, request)
  +                  return  referenceData state |> ingredients |> FormatPicker(f) |> OK
  +                })))
  +
  +            pathScan "/blueprints%s" (fun (format) -> 
  +              (request(fun request ->
  +                cmdr {
  +                  let! f = FormatExtractor(format, request)
  +                  return  referenceData state |> blueprints |> FormatPicker(f) |> OK
  +                })))
  +
  +            pathScan "/commanders%s" (fun (format) -> 
  +              (request(fun request ->
  +                cmdr {
  +                  let! f = FormatExtractor(format, request)
  +                  return  state.Invoke().Keys |> FormatPicker(f) |> OK
  +                })))
                  
  -            pathScan "/%s/cargo" (fun (commander) -> 
  -              cmdr {
  -                let! state = commanderRoute commander
  -                return cargoRoute(state, None)
  -            })
  -            pathScan "/%s/materials" (fun (commander) -> 
  -              cmdr {
  -                let! state = commanderRoute commander
  -                return cargoRoute(state, Some(Kind.Material))
  -            })
  -            pathScan "/%s/data" (fun (commander) -> 
  -              cmdr {
  -                let! state = commanderRoute commander
  -                return cargoRoute(state, Some(Kind.Data))
  -            })
  -            pathScan "/%s/commodities" (fun (commander) -> 
  -              cmdr {
  -                let! state = commanderRoute commander
  -                return cargoRoute(state, Some(Kind.Commodity))
  -            })
  -
  -            pathScan "/%s/operations" listOperations
  -             
  -            path "/kek" >=> (test <| (fun f -> referenceData state |> ingredients |> json |> OK))
  -            pathScan "/%s/kek.%s" (fun (commander, format) ->
  -                cmdr {
  -                  let! f = FormatExtractor format
  -                  return referenceData state |> ingredients |> FormatPicker(f) |> OK
  -                }
  -            )
  +            pathScan "/%s/cargo%s" (fun (commander, format) -> 
  +              (request(fun request ->
  +                cmdr {
  +                  let! s = commanderRoute commander
  +                  let! f = FormatExtractor(format, request)
  +                  return (s, None) |> cargoExtractor |> FormatPicker(f) |> OK
  +                })))
  +
  +            pathScan "/%s/materials%s" (fun (commander, format) -> 
  +              (request(fun request ->
  +                cmdr {
  +                    let! s = commanderRoute commander
  +                    let! f = FormatExtractor(format, request)
  +                    return (s, Some(Kind.Material)) |> cargoExtractor |> FormatPicker(f) |> OK
  +                })))
  +
  +            pathScan "/%s/data%s" (fun (commander, format) -> 
  +              (request(fun request ->
  +                cmdr {
  +                    let! s = commanderRoute commander
  +                    let! f = FormatExtractor(format, request)
  +                    return (s, Some(Kind.Data)) |> cargoExtractor |> FormatPicker(f) |> OK
  +                })))
  +
  +            pathScan "/%s/commodities%s" (fun (commander, format) -> 
  +              (request(fun request ->
  +                cmdr {
  +                    let! s = commanderRoute commander
  +                    let! f = FormatExtractor(format, request)
  +                    return (s, Some(Kind.Commodity)) |> cargoExtractor |> FormatPicker(f) |> OK
  +                })))
  +
  +            pathScan "/%s/operations%s" (fun (commander, format) ->
  +              (request(fun request ->
  +                let timestampString = match request.queryParam "last" with
  +                                      | Choice1Of2 s     -> Some(s)
  +                                      | Choice2Of2 other -> None
  +
  +                cmdr {
  +                  let! state = commanderRoute commander
  +                  let! f = FormatExtractor(format, request)
  +                  let! timestamp = timeRoute timestampString
  +                  return state.Operations
  +                          |> List.ofSeq
  +                          |> List.filter
  +                            (fun e -> match e.Timestamp with
  +                                      | t when t >= timestamp -> true
  +                                      | _                     -> false)
  +                          |> json 
  +                          |> OK
  +               })))
                
               NOT_FOUND "Route not found ¯\_(ツ)_/¯" ]
         ]
  
positive.code: 
    let referenceData = fun (state:Func<IDictionary<string, State>>) -> state.Invoke().First().Value
  
    let cargoExtractor = fun (commander:State, kind) -> commander.Cargo
                                                        |> List.ofSeq
                                                        |> List.filter 
                                                          (fun e -> match kind with
                                                                    | Some(Kind.Commodity) -> e.Value.Data.Kind = Kind.Commodity
                                                                    | Some(Kind.Data)      -> e.Value.Data.Kind = Kind.Data
                                                                    | Some(Kind.Material)  -> e.Value.Data.Kind = Kind.Material
                                                                    | _                    -> true)
                                                        |> List.map (fun e -> e.Value)
                                                        |> List.map (fun e -> e.Data.Name, e.Count)
                                                        |> dict
  
    let cargoRoute = fun(state, kind) -> (state, kind) |> cargoExtractor |> json |> OK
  
    let commanderRoute = fun commander ->
                           match state.Invoke().TryGetValue(commander) with
  
negative.code:     match format with
      | Some(f) -> f
      | _       -> Json
      
    let FormatExtractor = fun(extension, request:HttpRequest) ->
      match extension with
      | "json" -> KnownFormat Json
      | "csv"  -> KnownFormat Csv
      | "xml"  -> KnownFormat Xml
      | s when s.StartsWith(".") -> UnknownFormat s
      | s when s = "" -> 
        let formatFromRequest = AcceptExtractor request
        KnownFormat formatFromRequest
      | f      -> RouteNotFound f
  
    let da = fun format -> format |> json |> OK
  
    let FormatPicker = fun f ->
      match f with
  