public void viewCohortScore(){

        //put a null check here on 'co'
            CollatedMessage<ResultSet<LeaderboardRecord>> message = LeaderboardRecordsListMessage.Builder.newBuilder(co.leaderboard_id)
                                                               .filterByPagingToOwnerIds(Arrays.asList(co.cohort)).build();
            Deferred<ResultSet<LeaderboardRecord>> deferred = client.send(message);
            deferred.addCallback(new Callback<ResultSet<LeaderboardRecord>,ResultSet<LeaderboardRecord>>(){

                 @Override
                 public ResultSet<LeaderboardRecord> call(final ResultSet<LeaderboardRecord> result) throws Exception {


                if(result.getResults().size()< co.cohort.length){
                    List<String> missingUserIDs = new ArrayList<String>();

                    for (String c :co.cohort) {
                        boolean found = false;
                        for (LeaderboardRecord r: result.getResults()) {

                            if(r.getOwnerId() == c){
                                found = true;
                                break;
                            }

                        }

                        if(!found){
                            missingUserIDs.add(c);
                        }
                    }
                    Log.e(log, "value of missingUserIDs in view_cohort_score "+missingUserIDs);



                      if(missingUserIDs.size() > 0){


                          CollatedMessage<ResultSet<User>> message = UsersFetchMessage.Builder.newBuilder()
                                                                   .id(missingUserIDs.toString()).build();
                          Deferred<ResultSet<User>> deferred = client.send(message);
                          deferred.addCallback(new Callback<ResultSet<User>, ResultSet<User>>()            {
                            @Override

                            public ResultSet<User> call(ResultSet<User> usersResult) throws Exception {

                                act(result.getResults(),usersResult.getResults());
//                                Log.e(log, "inside view_cohort_score1"+result.getResults());
                                Log.e(log, "inside view_cohort_score1"+usersResult.getResults());


                                return usersResult;
                            }

                        }).addErrback(new Callback<Error, Error>() {
                            @Override
                            public Error call(Error err) throws Exception {
                                Log.e(log, "Error inside view_cohort_score1"+err.getCode() + ":" + err.getMessage());
                                return err;

                               }
                           });




                             }else{
                               act(result.getResults(), new ArrayList<User>());
                            }



                     }else{
                      act(result.getResults(), new ArrayList<User>());
                     }




                    return result;
                  }
              }).addErrback(new Callback<Error, Error>() {
                   @Override
                   public Error call(Error error) throws Exception {
                     Log.e(log,"Error inside view_cohort_score2" +error.getCode() +error.getMessage());

                      return error;
                   }
                 });


           }




            private void act(List<LeaderboardRecord> results, List<User> usersResultResults){

            // Here we receive a list of leaderboard records that have a score.
               for (LeaderboardRecord r: results) {

                Log.e(log,"User id: "+r.getOwnerId() +" has score of:" +r.getScore());

          }
 // Finally here are the cohort members that have no score yet this season.
        for (User u: usersResultResults) {

            Log.e(log,"User id: "+u.getId() +" has no score");

        }